【数据结构】C语言实现带头双向循环链表万字详解(附完整运行代码)

🦄个人主页:修修修也

🎏所属专栏:数据结构

⚙️操作环境:Visual Studio 2022

一.了解项目功能

在本次项目中我们的目标是实现一个带头双向循环链表:

该带头双向循环链表使用动态内存分配空间,可以用来存储任意数量的同类型数据.

带头双向循环链表结点(Node)需要包含三个要素:前指针域prev,数据域data,后指针域next.

结点(Node)逻辑结构图示如下:

带头双向循环链表提供的功能有:

  1. 带头双向循环链表的初始化.
  2. 带头双向循环链表的新节点创建.
  3. 带头双向循环链表元素的尾插.
  4. 带头双向循环链表元素的头插.
  5. 带头双向循环链表的元素位置查找.
  6. 带头双向循环链表的任意指定元素前插入.
  7. 带头双向循环链表的尾删.
  8. 带头双向循环链表的头删.
  9. 带头双向循环链表的任意指定元素删除.
  10. 带头双向循环链表打印.
  11. 带头双向循环链表的销毁.

二.项目功能演示

要编写一个带头双向循环链表项目，首先要明确我们想要达到的效果是什么样，下面我将用vs2022编译器来为大家演示一下带头双向循环链表程序运行时的样子：

三.逐步实现项目功能模块及其逻辑详解

通过第二部分对项目功能的介绍，我们已经对带头双向循环链表的功能有了大致的了解，虽然看似需要实现的功能很多，貌似一时间不知该如何下手，但我们可以分步分模块来分析这个项目的流程，最后再将各部分进行整合，所以大家不用担心，跟着我一步一步分析吧！

！！！注意，该部分的代码只是为了详细介绍某一部分的项目实现逻辑，故可能会删减一些与该部分不相关的代码以便大家理解，需要查看或拷贝完整详细代码的朋友可以移步本文第四部分。

1.实现单链表程序菜单

菜单部分的逻辑比较简单，就是利用C语言printf函数打印出这个菜单界面即可。但要注意菜单的标序要和后续switch...case语句的分支相应,以免导致后续执行语句错乱的问题.基础问题就不过多赘述了，代码如下：

该部分功能实现代码如下: 

//菜单
void LTMenu()
{printf("**********************************************\n");printf("******请选择要进行的操作                ******\n");printf("******1.双向带头循环链表尾插            ******\n");printf("******2.双向带头循环链表头插            ******\n");printf("******3.双向带头循环链表指定元素前插入  ******\n");printf("******4.双向带头循环链表尾删            ******\n");printf("******5.双向带头循环链表头删            ******\n");printf("******6.双向带头循环链表指定元素删除    ******\n");printf("******7.双向带头循环链表打印            ******\n");printf("******0.退出双向带头循环链表程序        ******\n");printf("**********************************************\n");printf("请选择:>");
}

2.实现单链表程序功能可循环使用

由于我们要实现带头双向循环链表的功能可以反复使用的逻辑，且至少在一开始执行一次,因此我们选择do...while的循环语句来实现这一部分的逻辑.

该部分功能实现代码如下: 

int main()
{LTNode* plist = LTInit();//初始化带头双向循环链表int swi = 0;//创建变量swi作为do...while循环的终止条件,以及switch语句的运行条件do          //使用do...while实现{LTMenu();scanf("%d", &swi);switch (swi){case 0:// 释放链表内存LTDestroy(plist);plist = NULL;printf("您已退出程序:>\n");break;case 1:printf("请输入要尾插的数据:>");LTDataType pushback_data = 0;scanf("%d", &pushback_data);LTPushBack(plist, pushback_data);printf("已成功插入:>\n");break;case 2:printf("请输入要头插的数据:>");LTDataType pushfront_data = 0;scanf("%d", &pushfront_data);LTPushFront(plist, pushfront_data);printf("已成功插入:>\n");break;case 3:printf("请输入要插入的数据:>");LTDataType insert_data = 0;scanf("%d", &insert_data);printf("请输入要插入的位置上的数据:>");LTDataType insert_posdata = 0;scanf("%d", &insert_posdata);LTNode* insert_pos = LTFind(plist, insert_posdata);if (insert_pos != NULL){LTInsert(insert_pos, insert_data);printf("已成功在'%d'数据前插入'%d':>\n", insert_posdata, insert_data);}else{printf("该元素不存在,无法插入:<\n");}break;case 4:LTPopBack(plist);printf("尾删成功:>\n");break;case 5:LTPopFront(plist);printf("头删成功:>\n");break;case 6:printf("请输入要删除的数据:>");LTDataType erase_data = 0;scanf("%d", &erase_data);LTNode* erase_pos = LTFind(plist, erase_data);if (erase_pos == NULL){printf("要删除的元素不存在:<\n");}else{LTErase(erase_pos);printf("已成功删除:>\n");}break;case 7:printf("打印双向带头循环链表:>\n");LTPrint(plist);break;default:printf("输入错误,请重新输入\n");break;}} while (swi);return 0;
}

3.创建带头双向循环链表

创建带头双向循环链表成员的结构体应该包括:存储上一结点位置的前指针域prev,存储数据的数据域data,存储下一个结点位置的后指针域next.

图示如下:

因此我们创建ListNode结构体类型时应由一个数据成员类型及两个指向该结构体的结构体指针组成.

这里的第一行使用的typedef类定义的作用是方便我们后续在使用带头双向循环链表时对存储的数据类型做更改,比如后续我们的带头双向循环链表不想存储int类型数据了,就可以很方便的在这里对带头双向循环链表数据域的存储数据类型做更改.比如改成char类型,或者double类型,甚至改成任意自己构造的结构类型.

在之前的实战项目通讯录中,我们就创建过类似的自定义结构体,如下图:

综上,该部分代码如下:

typedef int LTDataType;typedef struct ListNode
{struct ListNode* next;struct ListNode* prev;LTDataType data;}LTNode;

4.单链表的新节点创建

因为后续我们带头双向循环链表初始化,尾插,头插等插入操作时都需要先创建一个新结点,为了使代码的利用效率变高,我们不如将创建新节点这一操作封装成一个函数,后续当需要创建新节点时,直接调用该函数即可.

函数的参数需要接收新结点的数据域,至于新结点的指针域,在我们不清楚新结点的用途时,直接将其全部置为NULL即可.

该部分功能实现代码如下: 

LTNode* BuyListNode(LTDataType x)
{LTNode* node = (LTNode*)malloc(sizeof(LTNode));if (node == NULL){perror("malloc fail");return NULL;}node->next = NULL;node->prev = NULL;node->data = x;return node;
}

5.初始化带头双向循环链表

初始化带头双向循环链表部分和之前单链表中我们的处理方式不同,在无头单链表部分我们需要对链表的初始化的操作仅仅是创建一个指向NULL的头指针即可:

而在本次项目中,我们采用的是带头结点指针链表,因此在初始化的时候我们需要开辟一个头结点,并将它的prev指针和next指针都指向它自己:

该部分功能实现代码如下: 

LTNode* LTInit()
{LTNode* phead = BuyListNode(-1);//头结点数据域设为-1方便辨识phead->next = phead;phead->prev = phead;return phead;
}

6.带头双向循环链表元素的尾插

尾插示意图:

  

如图,我们在尾插时首先要找到原链表的尾,即head->prev,然后我们需要改变四个指针的指向关系:

  • 使旧尾的next连接上newnode
  • 使newnode的prev连接上旧尾
  • 使head的prev连接上newnode
  • 使newnode的next连接上head

然后尾插操作就完成了,该部分功能实现代码如下: 

void LTPushBack(LTNode* phead, LTDataType x)
{assert(phead);//带头结点的头指针必不为空.//单链表需要二级指针的原因是要改变头指针的指向,要改变指针只能用二级指针//要改变结构体的成员就不需要二级指针,只需要改变它存储的内容即可LTNode* newnode = BuyListNode(x);LTNode* tail = phead->prev;//链接新尾和旧尾tail->next = newnode;newnode->prev = tail;phead->prev = newnode;newnode->next = phead;}

7.带头双向循环链表元素的头插

头插示意图:

  

如图,我们在头插时首先需要找到旧头,即head->next,然后需要改变四个指针的指向关系:

  • 使newnode的next连接上旧头
  • 使旧头的prev连接上newnode
  • 使head的next连接上newnode
  • 使newnode的prev连接上head

 注意!在这部分,我们只使用head和nownode两个指针的情况下,一定要先让newnode和旧头链接起来,即图中的1操作,然后再将head和newnode连接起来,即图中的4操作.

因为,如果我们先更改了head的next指针的指向,后续想要找到旧头就只能再循环遍历一遍链表了,这样会非常麻烦.

这四个指针的顺序是可以更改的,但必须要保证第1步操作在第4步操作的前面,只要满足这个条件,剩下的顺序都是可以随意更改的.

然后头插操作就完成了,该部分功能实现代码如下: 

void LTPushFront(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);//双指针:先连后再连前newnode->next = phead->next;phead->next->prev = newnode;phead->next = newnode;newnode->prev = phead;//三指针顺序可以随便换
}

8.带头双向循环链表的元素位置查找

因为后续我们要使用的带头双向循环链表按位插入和按位删除都需要知道用户传入的链表元素在链表中的位置在哪,因此我们把查找链表元素位置的操作封装成一个单独的函数,后续需要查找某一链表元素的位置直接调用这个函数就行.

函数的参数应该接收待查找的结点的数据域,以便我们在遍历链表的过程中能够找到它.

函数的返回值是链表结点指针型(LTNode*),这样可以方便我们在找到要查找的指针后直接对齐进行相关操作,而不需要再在函数外再遍历一遍链表了.

对于带头双向循环链表的遍历,我们要特别注意,因为是循环链表,所以我们一般的遍历方式都是从头结点的后一个结点开始,直到走到头结点的时候才算结束.

该部分功能实现代码如下: 

LTNode* LTFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead->next;  //从头节点的后一个结点开始while (cur != phead){if (cur->data == x){return cur;}cur = cur->next;}return NULL;       //没找到,返回空
}

9.带头双向循环链表的任意指定元素前插入

因为我们只要知道某一结点的位置,就可以通过访问它的prev和next指针访问它的上一个或下一个结点,所以在指定元素前插入函数中我们只需要两个参数,一个是指定元素的位置,一个是新结点的数据域的数据值.

任意指定位置前插入示意图:

  

如图,我们这次创建一个指针p来记录下pos的前一个结点的位置,即使用三指针的方式来插入新数据,这时四个指针的修改顺序就可以任意书写了,我们可以先更改p指针的next指针了,我们改变下面四个指针的指向关系即可:

  • p的next连接上newnode
  • newnode的prev连接上p
  • newnode的next连接上pos
  • pos的prev连接上newnode

更改完我们的插入操作也就完成了,该部分代码实现如下:

//在pos位置之前插入一个值
void LTInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* newnode = BuyListNode(x);LTNode* p = pos->prev;p->next = newnode;newnode->prev = p;newnode->next = pos;pos->prev = newnode;//尾插pos传head//头插pos传head->next}

当我们拥有了任意位置前插入函数后, 其实就不需要再单独写尾插或头插函数了,当我们想要尾插时我们只需要给LTInsert函数传入head的地址就可以了,而当我们想要头插时我们只需要给LTInsert函数传入head->next的地址就可以了.

所以尾插函数可以直接写成:

void LTPushBack(LTNode* phead, LTDataType x)
{LTInsert(phead,x);
}

头插函数可以直接写成:

void LTPushFront(LTNode* phead, LTDataType x)
{LTInsert(phead->next,x);
}

10.带头双向循环链表的判空

因为我们在删除链表元素前都需要先判断一下链表当前是不是为空,如果链表为空那就不要再删了,因为尾删,头删,指定元素删除都需要判空操作,所以我们不如封装一个函数,在调用时判断当前链表是否为空,如果为空返回假,不为空返回真.

 该部分功能实现代码如下: 

bool LTEmpty(LTNode* phead)
{assert(phead);return phead->next != phead;   //简洁写法//完整写法,即phead的next不等于phead返回真(即链表不为空)//phead的next等于phead返回假(即链表为空)/*if (phead->next != phead){return true;}else{return false;}*/}

11.带头双向循环链表的尾删

尾删示意图:

  

如图,我们尾删前判断一下链表不为空的话就要找到尾结点,然后就可以开始尾删了.我们先创建一个指针tail记录下尾结点的位置,再创建一个指针tailPrev记录下尾结点的前一个结点(即新尾)的位置.

在删除时我们只需要改变两个指针的指向就可以了,即:

  •  使phead的prev指针指向新尾(tailPrev)
  • 使新尾(tailPrev)的next指针指向phead

 更改完我们的尾删操作也就完成了,该部分代码实现如下:

void LTPopBack(LTNode* phead)
{assert(phead);assert(LTEmpty(phead));LTNode* tail = phead->prev;LTNode* tailPrev = tail->prev;phead->prev = tailPrev;tailPrev->next = phead;free(tail);tail = NULL;
}

12.带头双向循环链表的头删

头删示意图:

如图,我们头删前判断一下链表不为空的话就要找到首结点,然后就可以开始头删了.我们先创建一个指针tail记录下首结点的位置.然后就可以开始删除了.

在删除时我们只需要改变两个指针的指向就可以了,即:

  •  使phead的next指针指向新首(tail->next)
  • 使新首(tail->next)的prev指针指向phead

 更改完我们的头删操作也就完成了,该部分代码实现如下:

void LTPopFront(LTNode* phead)
{assert(phead);assert(LTEmpty(phead));LTNode* tail = phead->next;phead->next = tail->next;tail->next->prev = phead;free(tail);tail = NULL;
}

13.带头双向循环链表的任意指定元素删除

删除任意指定元素示意图:

如图,我们任意位置删前判断一下链表不为空的话就要找到待删结点的前驱结点和后继结点,然后就可以开始删除了.我们创建一个指针p记录下待删结点的前驱结点的位置.再创建一个指针n记录下待删结点的后继结点的位置,然后就可以开始删除了.

在删除时我们只需要改变两个指针的指向就可以了,即:

  • 使前驱结点p的next指针指向后继结点n
  • 使后继结点n的prev指针指向前驱结点p

 更改完我们的删除操作也就完成了,该部分代码实现如下:

//删除pos位置的值
void LTErase(LTNode* pos)
{assert(pos);LTNode* p = pos->prev;LTNode* n = pos->next;n->prev = p;p->next = n;free(pos);pos = NULL;//头删传phead->next//尾删传phead->prev}

当我们拥有了任意位置前删除函数后, 其实就不需要再单独写尾删或头删函数了,当我们想要尾删时我们只需要给LTErase函数传入phead->prev的地址就可以了,而当我们想要头删时我们只需要给LTErase函数传入phead->next的地址就可以了.

所以尾删函数可以直接写成:

void LTPopBack(LTNode* phead, LTDataType x)
{LTErase(phead->prev,x);
}

头删函数可以直接写成:

void LTPopFront(LTNode* phead, LTDataType x)
{LTErase(phead->next,x);
}

14.带头双向循环链表打印

在打印部分我们要注意的是:循环链表和单链表的主要差异就在于循环遍历时的判断条件上,原来是判断p->next是否为NULL,现在则是p->next不等于头结点,则循环遍历未结束.

了解了这点后,带头双向循环链表的打印逻辑很简单,顺着头指针的后一个结点向后循环遍历打印整个链表结点的数据域即可,当遍历指针再次走到head结点时,则代表已经遍历打印完链表的所有元素,这时跳出循环即可.

该部分功能实现代码如下: 

void LTPrint(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;printf("<->Head<->");while (cur != phead){printf("%d<->",cur->data);cur = cur->next;}printf("\n");
}

15.带头双向循环链表的销毁

当我们使用完双向带头循环链表想要退出程序时,就应该将之前动态开辟的内存释放掉,还给操作系统.即销毁双向带头循环链表操作.

我们使用free()函数将前面开辟的结点的内存逐一释放,释放完将头指针置为空即可.

要注意,这里循环链表的遍历从头结点的后一个结点开始,然后循环遍历时的判断条件p->next不等于头结点,则循环遍历未结束.

 该部分功能实现代码如下:

void LTDestroy(LTNode*phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);//让调用的人置空
}

四.项目完整代码

我们将程序运行的代码分别在三个工程文件中编辑,完整代码如下:

test.c文件

#include"List.h"int main()
{LTNode* plist = LTInit();int swi = 0;//创建变量swi作为do...while循环的终止条件,以及switch语句的运行条件do          //使用do...while实现{LTMenu();scanf("%d", &swi);switch (swi){case 0:// 释放链表内存LTDestroy(plist);plist = NULL;printf("您已退出程序:>\n");break;case 1:printf("请输入要尾插的数据:>");LTDataType pushback_data = 0;scanf("%d", &pushback_data);LTPushBack(plist, pushback_data);printf("已成功插入:>\n");break;case 2:printf("请输入要头插的数据:>");LTDataType pushfront_data = 0;scanf("%d", &pushfront_data);LTPushFront(plist, pushfront_data);printf("已成功插入:>\n");break;case 3:printf("请输入要插入的数据:>");LTDataType insert_data = 0;scanf("%d", &insert_data);printf("请输入要插入的位置上的数据:>");LTDataType insert_posdata = 0;scanf("%d", &insert_posdata);LTNode* insert_pos = LTFind(plist, insert_posdata);if (insert_pos != NULL){LTInsert(insert_pos, insert_data);printf("已成功在'%d'数据前插入'%d':>\n", insert_posdata, insert_data);}else{printf("该元素不存在,无法插入:<\n");}break;case 4:LTPopBack(plist);printf("尾删成功:>\n");break;case 5:LTPopFront(plist);printf("头删成功:>\n");break;case 6:printf("请输入要删除的数据:>");LTDataType erase_data = 0;scanf("%d", &erase_data);LTNode* erase_pos = LTFind(plist, erase_data);if (erase_pos == NULL){printf("要删除的元素不存在:<\n");}else{LTErase(erase_pos);printf("已成功删除:>\n");}break;case 7:printf("打印双向带头循环链表:>\n");LTPrint(plist);break;default:printf("输入错误,请重新输入\n");break;}} while (swi);return 0;
}

List.c文件

#include"List.h"//菜单
void LTMenu()
{printf("**********************************************\n");printf("******请选择要进行的操作                ******\n");printf("******1.双向带头循环链表尾插            ******\n");printf("******2.双向带头循环链表头插            ******\n");printf("******3.双向带头循环链表指定元素前插入  ******\n");printf("******4.双向带头循环链表尾删            ******\n");printf("******5.双向带头循环链表头删            ******\n");printf("******6.双向带头循环链表指定元素删除    ******\n");printf("******7.双向带头循环链表打印            ******\n");printf("******0.退出双向带头循环链表程序        ******\n");printf("**********************************************\n");printf("请选择:>");
}LTNode* LTInit()
{LTNode* phead = BuyListNode(-1);phead->next = phead;phead->prev = phead;return phead;
}void LTDestroy(LTNode*phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);//让调用的人置空
}LTNode* BuyListNode(LTDataType x)
{LTNode* node = (LTNode*)malloc(sizeof(LTNode));if (node == NULL){perror("malloc fail");return NULL;}node->next = NULL;node->prev = NULL;node->data = x;return node;
}void LTPrint(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;printf("<->Head<->");while (cur != phead){printf("%d<->",cur->data);cur = cur->next;}printf("\n");
}bool LTEmpty(LTNode* phead)
{assert(phead);return phead->next != phead;/*if (phead->next != phead){return true;}else{return false;}*/}void LTPushBack(LTNode* phead, LTDataType x)
{assert(phead);//带头结点的头指针必不为空.//单链表需要二级指针的原因是要改变头指针的指向,要改变指针只能用二级指针//要改变结构体的成员就不需要二级指针,只需要改变它存储的内容即可LTNode* newnode = BuyListNode(x);LTNode* tail = phead->prev;//链接新尾和旧尾tail->next = newnode;newnode->prev = tail;phead->prev = newnode;newnode->next = phead;}void LTPopBack(LTNode* phead)
{assert(phead);assert(LTEmpty(phead));LTNode* tail = phead->prev;LTNode* tailPrev = tail->prev;phead->prev = tailPrev;tailPrev->next = phead;free(tail);tail = NULL;
}void LTPushFront(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);//双指针:先连后再连前newnode->next = phead->next;phead->next->prev = newnode;phead->next = newnode;newnode->prev = phead;//三指针顺序随便换
}void LTPopFront(LTNode* phead)
{assert(phead);assert(LTEmpty(phead));LTNode* tail = phead->next;phead->next = tail->next;tail->next->prev = phead;free(tail);tail = NULL;
}LTNode* LTFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}//在pos位置之前插入一个值
void LTInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* newnode = BuyListNode(x);LTNode* p = pos->prev;p->next = newnode;newnode->prev = p;newnode->next = pos;pos->prev = newnode;//尾插pos传head//头插pos传head->next}//删除pos位置的值
void LTErase(LTNode* pos)
{assert(pos);LTNode* p = pos->prev;LTNode* n = pos->next;n->prev = p;p->next = n;free(pos);pos = NULL;//头删传phead->next//尾删传phead->prev}

List.h文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdlib.h>
#include<assert.h>
#include<stdio.h>
#include<stdbool.h>typedef int LTDataType;typedef struct ListNode
{struct ListNode* next;struct ListNode* prev;LTDataType data;}LTNode;void LTMenu();LTNode* LTInit();LTNode* BuyListNode(LTDataType x);LTNode* LTFind(LTNode* phead, LTDataType x);void LTDestroy(LTNode* phead);void LTPrint(LTNode* phead);bool LTEmpty(LTNode* phead);void LTPushBack(LTNode* phead, LTDataType x);void LTPopBack(LTNode* phead);void LTPushFront(LTNode* phead, LTDataType x);void LTPopFront(LTNode* phead);void LTInsert(LTNode* pos,LTDataType x);void LTErase(LTNode* pos);

结语

希望这篇双向带头循环表的实现详解能对大家有所帮助,欢迎大佬们留言或私信与我交流.

学海漫浩浩,我亦苦作舟!关注我,大家一起学习,一起进步!

相关文章推荐

【数据结构】什么是线性表?

【数据结构】线性表的链式存储结构

【C语言】free()函数详解(动态内存释放函数)

【C语言】malloc()函数详解(动态内存开辟函数)
【数据结构】链表的八种形态
【数据结构】C语言实现单链表万字详解(附完整运行代码)

【实用编程技巧】不想改bug?初学者必须学会使用的报错函数assert!(断言函数详解)

数据结构线性篇思维导图:

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/152841.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Windows 安装 Docker Compose

Windows 安装 Docker Compose

目录 前言什么是 Docker Compose &#xff1f;安装 Docker Compose配置环境变量结语开源项目 前言 在当今软件开发和部署领域&#xff0c;容器化技术的应用已成为提高效率和系统可移植性的关键手段。Docker&#xff0c;作为领先的容器化平台&#xff0c;为开发人员提供了轻松构…
阅读更多...
矩阵的QR分解

矩阵的QR分解

矩阵的QR分解 GramSchmidt 设存在 B { x 1 , x 2 , … , x n } \mathcal{B}\left\{\mathbf{x}_{1},\mathbf{x}_{2},\ldots,\mathbf{x}_{n}\right\} B{x1​,x2​,…,xn​}在施密特正交化过程中 q 1 x 1 ∣ ∣ x 1 ∣ ∣ q_1\frac{x_1}{||x_1||} q1​∣∣x1​∣∣x1​​ q k …
阅读更多...
Axure RP Pro 8 mac/win中文版：打造无限可能的原型设计工具

Axure RP Pro 8 mac/win中文版：打造无限可能的原型设计工具

在如今的数字化时代&#xff0c;原型设计工具越来越受到设计师和产品经理们的重视。而Axure RP Pro8作为一款强大的原型设计工具&#xff0c;成为了众多专业人士的首选。 首先&#xff0c;Axure RP Pro8具备丰富的功能。它提供了多种交互元素和动画效果&#xff0c;使得用户可…
阅读更多...
SR-LIO--手写紧耦合IESKF

SR-LIO--手写紧耦合IESKF

1.ESKF初始化 void eskfEstimator::tryInit(const std::vector<std::pair<double, std::pair<Eigen::Vector3d, Eigen::Vector3d>>> &imu_meas) { //通过imu测量值初始化均值&#xff0c;协方差&#xff1b;(均值用于初始化零偏&#xff0c;协方差用于…
阅读更多...
鸿蒙应用开发初尝试《创建项目》，之前那篇hello world作废

鸿蒙应用开发初尝试《创建项目》，之前那篇hello world作废

经过几年的迅速发展&#xff0c;鸿蒙抛弃了JAVA写应用的方式&#xff0c;几年前了解的鸿蒙显然就gg了。 这几年鸿蒙发布了方舟&#xff08;ArkUI Arkts&#xff09;&#xff0c;将TypeScript作为了推荐开发语言&#xff0c;你依然可以用FAJS,但华为推荐用StageArkTs!!!那么你还…
阅读更多...
Java架构师软件架构设计导论

Java架构师软件架构设计导论

目录 1 软件架构设计导论2 HR角度看架构师3 软件架构设计概述4 顶级大师眼中的架构5 建筑中的架构师6 软件架构的发展阶段7 软件架构的意义8 架构是项目干系人进行交流的手段9 架构有助于循序渐进的原型设计10 架构是设计决策的体现11 架构明确系统设计约束条件12 架构与组织结…
阅读更多...
二阶低通滤波器（二阶巴特沃斯滤波器）

二阶低通滤波器（二阶巴特沃斯滤波器）

连续传递函数G(s) 离散传递函数G(z) 差分方程形式 二阶巴特沃斯滤波器参数设计 设计采样频率100Hz&#xff0c;截止频率33Hz。 注意&#xff1a;设计参数使用在离散系统中&#xff01; 同理&#xff0c;其他不同阶数不同类型的滤波器设计&#xff0c;如二阶高通滤波器、二阶…
阅读更多...
计算机网络（持续更新…）

计算机网络（持续更新…）

文章目录 一、概述1. 计网概述⭐ 发展史⭐ 基本概念⭐ 分类⭐ 数据交换方式&#x1f970; 小练 2. 分层体系结构⭐ OSI 参考模型⭐TCP/IP 参考模型&#x1f970; 小练 二、物理层1. 物理层概述⭐ 四个特性 2. 通信基础⭐ 重点概念⭐ 极限数据传输率⭐ 信道复用技术&#x1f389…
阅读更多...
axios的原理及实现一个简易版axios

axios的原理及实现一个简易版axios

面试官&#xff1a;你了解axios的原理吗&#xff1f;有看过它的源码吗&#xff1f; 一、axios的使用 关于axios的基本使用&#xff0c;上篇文章已经有所涉及&#xff0c;这里再稍微回顾下&#xff1a; 发送请求 import axios from axios;axios(config) // 直接传入配置 axio…
阅读更多...
第十五章---I/O（输入/输出）

第十五章---I/O（输入/输出）

15.1输入输出流 流是一组有序的数据序列&#xff0c;根据操作的类型&#xff0c;可分为输入流和输出流两种。I/O(Input/Output,(输出)流提供了一条通道程序&#xff0c;可以使用这条通道把源中的字节序列送到目的地。虽然 I/O 流疆盘文件存取有关&#xff0c;但是程序的源和目…
阅读更多...
华为---OSPF网络虚连接（Virtual Link）简介及示例配置

华为---OSPF网络虚连接（Virtual Link）简介及示例配置

OSPF网络虚连接&#xff08;Virtual Link&#xff09;简介 为了避免区域间的环路&#xff0c;OSPF规定不允许直接在两个非骨干区域之间发布路由信息&#xff0c;只允许在一个区域内部或者在骨干区域和非骨干区域之间发布路由信息。因此&#xff0c;每个ABR都必须连接到骨干区域…
阅读更多...
QT基础学习

QT基础学习

2创建项目 2.1使用向导创建 打开Qt Creator 界面选择 New Project或者选择菜单栏 【文件】-【新建文件或项目】菜单项 弹出New Project对话框&#xff0c;选择Qt Widgets Application&#xff0c; 选择【Choose】按钮&#xff0c;弹出如下对话框 设置项目名称和路径&#xf…
阅读更多...
N 字形变换

N 字形变换

将一个给定字符串 s 根据给定的行数 numRows &#xff0c;以从上往下、从左到右进行 Z 字形排列。 比如输入字符串为 “PAYPALISHIRING” 行数为 3 时&#xff0c;排列如下&#xff1a; P A H N A P L S I I G Y I R 之后&#xff0c;你的输出需要从左往右逐行读取&#xff0…
阅读更多...
网络参考模型与标准协议（一）

网络参考模型与标准协议（一）

OSI参考模型 OSI 模型(Open Systems Interconnection Model)&#xff0c;由国际化标准组织ISO (TheInternational Organization for Standardization )收录在ISO 7489标准中并于1984年发布。 OSI参考模型又被称为七层模型&#xff0c;由下至上依次为: 物理层: 在设备之间传输比…
阅读更多...
Linux编辑器-gcc/g++使用

Linux编辑器-gcc/g++使用

> 作者简介&#xff1a;დ旧言~&#xff0c;目前大二&#xff0c;现在学习Java&#xff0c;c&#xff0c;c&#xff0c;Python等 > 座右铭&#xff1a;松树千年终是朽&#xff0c;槿花一日自为荣。 > 目标&#xff1a;熟练使用gcc/g编译器 > 毒鸡汤&#xff1a;真正…
阅读更多...
75基于matlab的模拟退火算法优化TSP(SA-TSP)，最优路径动态寻优，输出最优路径值、路径曲线、迭代曲线。

75基于matlab的模拟退火算法优化TSP(SA-TSP)，最优路径动态寻优，输出最优路径值、路径曲线、迭代曲线。

基于matlab的模拟退火算法优化TSP(SA-TSP)&#xff0c;最优路径动态寻优&#xff0c;输出最优路径值、路径曲线、迭代曲线。数据可更换自己的&#xff0c;程序已调通&#xff0c;可直接运行。 75matlab模拟退火算法TSP问题 (xiaohongshu.com)
阅读更多...
如何通过cpolar内网穿透工具实现远程访问本地postgreSQL

如何通过cpolar内网穿透工具实现远程访问本地postgreSQL

文章目录 前言1. 安装postgreSQL2. 本地连接postgreSQL3. Windows 安装 cpolar4. 配置postgreSQL公网地址5. 公网postgreSQL访问6. 固定连接公网地址7. postgreSQL固定地址连接测试 前言 PostgreSQL是一个功能非常强大的关系型数据库管理系统&#xff08;RDBMS&#xff09;,下…
阅读更多...
uniapp开发小程序，包过大解决方案

uniapp开发小程序，包过大解决方案

1、首先和大家说一下 微信小程序 主包限制不能超过2M 分包一共不能超过8M 然后具体解决优化步骤如下&#xff0c; 将主包进行分包 在pages.json 下subPackages里面进行配置分包 分包配置完 配置过的文件都需要进行修改对应的路径 2 、 在运行的时候 一定要勾选 压缩代码 有…
阅读更多...
Android Termux安装MySQL，内网穿透实现公网远程访问

Android Termux安装MySQL，内网穿透实现公网远程访问

文章目录 前言1.安装MariaDB2.安装cpolar内网穿透工具3. 创建安全隧道映射mysql4. 公网远程连接5. 固定远程连接地址 前言 Android作为移动设备&#xff0c;尽管最初并非设计为服务器&#xff0c;但是随着技术的进步我们可以将Android配置为生产力工具&#xff0c;变成一个随身…
阅读更多...
【电路笔记】-欧姆定律

【电路笔记】-欧姆定律

欧姆定律 文章目录 欧姆定律1、概述2、AC电路的等效性2.1 输入电阻2.2 输入电感2.3 输入电容 3、欧姆定律的局部形式3.1 介绍和定义3.2 德鲁德模型(Drude Model)3.3 局部形式表达式 4、电阻和宏观欧姆定律5、总结 电流、电压和电阻之间的基本关系被称为欧姆定律&#xff0c;可能…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023