首页 > 其他分享 >单链表及其基本操作

单链表及其基本操作

时间：2022-10-20 09:23:43浏览次数：78  
标签：结点 单链 temp int 及其 elem next 链表 基本操作

逻辑结构上一个挨一个的数据，在实际存储时，并没有像顺序表那样也相互紧挨着。恰恰相反，数据随机分布在内存中的各个位置，这种存储结构称为线性表的链式存储。

由于分散存储，为了能够体现出数据元素之间的逻辑关系，每个数据元素在存储的同时，要配备一个指针，用于指向它的直接后继元素，即每一个数据元素都指向下一个数据元素（最后一个指向NULL(空)）。


图1 链式存储存放数据
如图1所示，当每一个数据元素都和它下一个数据元素用指针链接在一起时，就形成了一个链，这个链子的头就位于第一个数据元素，这样的存储方式就是链式存储。

线性表的链式存储结构生成的表，称作“链表”。

链表中数据元素的构成

每个元素本身由两部分组成：
  1. 本身的信息，称为“数据域”；
  2. 指向直接后继的指针，称为“指针域”。
 
图2 结点的构成 这两部分信息组成数据元素的存储结构，称之为“结点”。n个结点通过指针域相互链接，组成一个链表。


图3 含有n个结点的链表
  图 3 中，由于每个结点中只包含一个指针域，生成的链表又被称为 线性链表 或 单链表。

链表中存放的不是基本数据类型，需要用结构体实现自定义：
  1. typedef struct Link{
  2. char elem;//代表数据域
  3. struct Link * next;//代表指针域，指向直接后继元素
  4. }link;

头结点、头指针和首元结点

头结点：有时，在链表的第一个结点之前会额外增设一个结点，结点的数据域一般不存放数据（有些情况下也可以存放链表的长度等信息），此结点被称为头结点。

若头结点的指针域为空（NULL），表明链表是空表。头结点对于链表来说，不是必须的，在处理某些问题时，给链表添加头结点会使问题变得简单。

首元结点：链表中第一个元素所在的结点，它是头结点后边的第一个结点。

头指针：永远指向链表中第一个结点的位置（如果链表有头结点，头指针指向头结点；否则，头指针指向首元结点）。
头结点和头指针的区别：头指针是一个指针，头指针指向链表的头结点或者首元结点；头结点是一个实际存在的结点，它包含有数据域和指针域。两者在程序中的直接体现就是：头指针只声明而没有分配存储空间，头结点进行了声明并分配了一个结点的实际物理内存。
图 4 头结点、头指针和首元结点

单链表中可以没有头结点，但是不能没有头指针！

链表的创建和遍历

万事开头难，初始化链表首先要做的就是创建链表的头结点或者首元结点。创建的同时，要保证有一个指针永远指向的是链表的表头，这样做不至于丢失链表。

例如创建一个链表（1，2，3，4）:
  1. link * initLink(){
  2. link * p=(link*)malloc(sizeof(link));//创建一个头结点
  3. link * temp=p;//声明一个指针指向头结点，用于遍历链表
  4. //生成链表
  5. for (int i=1; i<5; i++) {
  6. link *a=(link*)malloc(sizeof(link));
  7. a->elem=i;
  8. a->next=NULL;
  9. temp->next=a;
  10. temp=temp->next;
  11. }
  12. return p;
  13. }

链表中查找某结点

一般情况下，链表只能通过头结点或者头指针进行访问，所以实现查找某结点最常用的方法就是对链表中的结点进行逐个遍历。

实现代码：
  1. int selectElem(link * p,int elem){
  2. link * t=p;
  3. int i=1;
  4. while (t->next) {
  5. t=t->next;
  6. if (t->elem==elem) {
  7. return i;
  8. }
  9. i++;
  10. }
  11. return -1;
  12. }

链表中更改某结点的数据域

链表中修改结点的数据域，通过遍历的方法找到该结点，然后直接更改数据域的值。

实现代码：
  1. //更新函数，其中，add 表示更改结点在链表中的位置，newElem 为新的数据域的值
  2. link *amendElem(link * p,int add,int newElem){
  3. link * temp=p;
  4. temp=temp->next;//在遍历之前，temp指向首元结点
  5. //遍历到被删除结点
  6. for (int i=1; i<add; i++) {
  7. temp=temp->next;
  8. }
  9. temp->elem=newElem;
  10. return p;
  11. }

向链表中插入结点

链表中插入头结点，根据插入位置的不同，分为3种：
  1. 插入到链表的首部，也就是头结点和首元结点中间；
  2. 插入到链表中间的某个位置；
  3. 插入到链表最末端；

图 5 链表中插入结点5
虽然插入位置有区别，都使用相同的插入手法。分为两步，如图 5 所示：
  • 将新结点的next指针指向插入位置后的结点；
  • 将插入位置前的结点的next指针指向插入结点；

提示：在做插入操作时，首先要找到插入位置的上一个结点，图4中，也就是找到结点 1，相应的结点 2 可通过结点 1 的 next 指针表示，这样，先进行步骤 1，后进行步骤 2，实现过程中不需要添加其他辅助指针。

实现代码：
  1. link * insertElem(link * p,int elem,int add){
  2. link * temp=p;//创建临时结点temp
  3. //首先找到要插入位置的上一个结点
  4. for (int i=1; i<add; i++) {
  5. if (temp==NULL) {
  6. printf("插入位置无效\n");
  7. return p;
  8. }
  9. temp=temp->next;
  10. }
  11. //创建插入结点c
  12. link * c=(link*)malloc(sizeof(link));
  13. c->elem=elem;
  14. //向链表中插入结点
  15. c->next=temp->next;
  16. temp->next=c;
  17. return p;
  18. }
注意：首先要保证插入位置的可行性，例如图 5 中，原本只有 5 个结点，插入位置可选择的范围为：1-6，如果超过6，本身不具备任何意义，程序提示插入位置无效。

从链表中删除节点

当需要从链表中删除某个结点时，需要进行两步操作：
  • 将结点从链表中摘下来;
  • 手动释放掉结点，回收被结点占用的内存空间;

 

使用malloc函数申请的空间，一定要注意手动free掉。否则在程序运行的整个过程中，申请的内存空间不会自己释放（只有当整个程序运行完了以后，这块内存才会被回收），造成内存泄漏，别把它当成是小问题。
实现代码：
  1. link * delElem(link * p,int add){
  2. link * temp=p;
  3. //temp指向被删除结点的上一个结点
  4. for (int i=1; i<add; i++) {
  5. temp=temp->next;
  6. }
  7. link * del=temp->next;//单独设置一个指针指向被删除结点，以防丢失
  8. temp->next=temp->next->next;//删除某个结点的方法就是更改前一个结点的指针域
  9. free(del);//手动释放该结点，防止内存泄漏
  10. return p;
  11. }

完整代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Link{
  5. int elem;
  6. struct Link *next;
  7. }link;
  8. link * initLink();
  9. //链表插入的函数，p是链表，elem是插入的结点的数据域，add是插入的位置
  10. link * insertElem(link * p,int elem,int add);
  11. //删除结点的函数，p代表操作链表，add代表删除节点的位置
  12. link * delElem(link * p,int add);
  13. //查找结点的函数，elem为目标结点的数据域的值
  14. int selectElem(link * p,int elem);
  15. //更新结点的函数，newElem为新的数据域的值
  16. link *amendElem(link * p,int add,int newElem);
  17. void display(link *p);
  19. int main() {
  20. //初始化链表（1，2，3，4）
  21. printf("初始化链表为：\n");
  22. link *p=initLink();
  23. display(p);
  25. printf("在第4的位置插入元素5：\n");
  26. p=insertElem(p, 5, 4);
  27. display(p);
  29. printf("删除元素3:\n");
  30. p=delElem(p, 3);
  31. display(p);
  33. printf("查找元素2的位置为：\n");
  34. int address=selectElem(p, 2);
  35. if (address==-1) {
  36. printf("没有该元素");
  37. }else{
  38. printf("元素2的位置为：%d\n",address);
  39. }
  40. printf("更改第3的位置的数据为7:\n");
  41. p=amendElem(p, 3, 7);
  42. display(p);
  44. return 0;
  45. }
  47. link * initLink(){
  48. link * p=(link*)malloc(sizeof(link));//创建一个头结点
  49. link * temp=p;//声明一个指针指向头结点，用于遍历链表
  50. //生成链表
  51. for (int i=1; i<5; i++) {
  52. link *a=(link*)malloc(sizeof(link));
  53. a->elem=i;
  54. a->next=NULL;
  55. temp->next=a;
  56. temp=temp->next;
  57. }
  58. return p;
  59. }
  60. link * insertElem(link * p,int elem,int add){
  61. link * temp=p;//创建临时结点temp
  62. //首先找到要插入位置的上一个结点
  63. for (int i=1; i<add; i++) {
  64. if (temp==NULL) {
  65. printf("插入位置无效\n");
  66. return p;
  67. }
  68. temp=temp->next;
  69. }
  70. //创建插入结点c
  71. link * c=(link*)malloc(sizeof(link));
  72. c->elem=elem;
  73. //向链表中插入结点
  74. c->next=temp->next;
  75. temp->next=c;
  76. return p;
  77. }
  79. link * delElem(link * p,int add){
  80. link * temp=p;
  81. //遍历到被删除结点的上一个结点
  82. for (int i=1; i<add; i++) {
  83. temp=temp->next;
  84. }
  85. link * del=temp->next;//单独设置一个指针指向被删除结点，以防丢失
  86. temp->next=temp->next->next;//删除某个结点的方法就是更改前一个结点的指针域
  87. free(del);//手动释放该结点，防止内存泄漏
  88. return p;
  89. }
  90. int selectElem(link * p,int elem){
  91. link * t=p;
  92. int i=1;
  93. while (t->next) {
  94. t=t->next;
  95. if (t->elem==elem) {
  96. return i;
  97. }
  98. i++;
  99. }
  100. return -1;
  101. }
  102. link *amendElem(link * p,int add,int newElem){
  103. link * temp=p;
  104. temp=temp->next;//tamp指向首元结点
  105. //temp指向被删除结点
  106. for (int i=1; i<add; i++) {
  107. temp=temp->next;
  108. }
  109. temp->elem=newElem;
  110. return p;
  111. }
  112. void display(link *p){
  113. link* temp=p;//将temp指针重新指向头结点
  114. //只要temp指针指向的结点的next不是Null，就执行输出语句。
  115. while (temp->next) {
  116. temp=temp->next;
  117. printf("%d",temp->elem);
  118. }
  119. printf("\n");
  120. }
运行结果： 
初始化链表为：
1234
在第4的位置插入元素5：
12354
删除元素3:
1254
查找元素2的位置为：
元素2的位置为：2
更改第3的位置的数据为7:
1274

总结

线性表的链式存储相比于顺序存储，有两大优势：
  1. 链式存储的数据元素在物理结构没有限制，当内存空间中没有足够大的连续的内存空间供顺序表使用时，可能使用链表能解决问题。（链表每次申请的都是单个数据元素的存储空间，可以利用上一些内存碎片）
  2. 链表中结点之间采用指针进行链接，当对链表中的数据元素实行插入或者删除操作时，只需要改变指针的指向，无需像顺序表那样移动插入或删除位置的后续元素，简单快捷。


链表和顺序表相比，不足之处在于，当做遍历操作时，由于链表中结点的物理位置不相邻，使得计算机查找起来相比较顺序表，速度要慢。

 

基本操作

学会创建链表之后，本节继续讲解链表的一些基本操作，包括向链表中添加数据、删除链表中的数据、查找和更改链表中的数据。

首先，创建一个带头结点的链表，链表中存储着 {1,2,3,4}：

  1. //链表中节点的结构
  2. typedef struct link {
  3. int elem;
  4. struct link* next;
  5. }Link;
  6. Link* initLink() {
  7. int i;
  8. //1、创建头指针
  9. Link* p = NULL;
  10. //2、创建头结点
  11. Link* temp = (Link*)malloc(sizeof(Link));
  12. temp->elem = 0;
  13. temp->next = NULL;
  14. //头指针指向头结点
  15. p = temp;
  16. //3、每创建一个结点，都令其直接前驱结点的指针指向它
  17. for (i = 1; i < 5; i++) {
  18. //创建一个结点
  19. Link* a = (Link*)malloc(sizeof(Link));
  20. a->elem = i;
  21. a->next = NULL;
  22. //每次 temp 指向的结点就是 a 的直接前驱结点
  23. temp->next = a;
  24. //temp指向下一个结点（也就是a),为下次添加结点做准备
  25. temp = temp->next;
  26. }
  27. return p;
  28. }

 

链表插入元素

同顺序表一样，向链表中增添元素，根据添加位置不同，可分为以下 3 种情况：

  • 插入到链表的头部，作为首元节点；
  • 插入到链表中间的某个位置；
  • 插入到链表的最末端，作为链表中最后一个结点；


对于有头结点的链表，3 种插入元素的实现思想是相同的，具体步骤是：

  1. 将新结点的 next 指针指向插入位置后的结点；
  2. 将插入位置前结点的 next 指针指向插入结点；

例如，在链表 {1,2,3,4} 的基础上分别实现在头部、中间、尾部插入新元素 5，其实现过程如图 1 所示：


图 1 带头结点链表插入元素的 3 种情况


从图中可以看出，虽然新元素的插入位置不同，但实现插入操作的方法是一致的，都是先执行步骤 1 ，再执行步骤 2。实现代码如下：

  1. void insertElem(Link* p, int elem, int add) {
  2. int i;
  3. Link* c = NULL;
  4. Link* temp = p;//创建临时结点temp
  5. //首先找到要插入位置的上一个结点
  6. for (i = 1; i < add; i++) {
  7. temp = temp->next;
  8. if (temp == NULL) {
  9. printf("插入位置无效\n");
  10. return;
  11. }
  12. }
  13. //创建插入结点c
  14. c = (Link*)malloc(sizeof(Link));
  15. c->elem = elem;
  16. //① 将新结点的 next 指针指向插入位置后的结点
  17. c->next = temp->next;
  18. //② 将插入位置前结点的 next 指针指向插入结点；
  19. temp->next = c;
  20. }

 

注意：链表插入元素的操作必须是先步骤 1，再步骤 2；反之，若先执行步骤 2，除非再添加一个指针，作为插入位置后续链表的头指针，否则会导致插入位置后的这部分链表丢失，无法再实现步骤 1。


对于没有头结点的链表，在头部插入结点比较特殊，需要单独实现。


图 2 不带头结点链表插入元素的 3 种情况


和 2)、3) 种情况相比，由于链表没有头结点，在头部插入新结点，此结点之前没有任何结点，实现的步骤如下：

  1. 将新结点的指针指向首元结点；
  2. 将头指针指向新结点。


实现代码如下：

  1. Link* insertElem(Link* p, int elem, int add) {
  2. if (add == 1) {
  3. //创建插入结点c
  4. Link* c = (Link*)malloc(sizeof(Link));
  5. c->elem = elem;
  6. c->next = p;
  7. p = c;
  8. return p;
  9. }
  10. else {
  11. int i;
  12. Link* c = NULL;
  13. Link* temp = p;//创建临时结点temp
  14. //首先找到要插入位置的上一个结点
  15. for (i = 1; i < add-1; i++) {
  16. temp = temp->next;
  17. if (temp == NULL) {
  18. printf("插入位置无效\n");
  19. return p;
  20. }
  21. }
  22. //创建插入结点c
  23. c = (Link*)malloc(sizeof(Link));
  24. c->elem = elem;
  25. //向链表中插入结点
  26. c->next = temp->next;
  27. temp->next = c;
  28. return p;
  29. }
  30. }

 

注意当 add==1 成立时，形参指针 p 的值会发生变化，因此需要它的新值作为函数的返回值返回。

 

链表删除元素

从链表中删除指定数据元素时，实则就是将存有该数据元素的节点从链表中摘除。

对于有头结点的链表来说，无论删除头部（首元结点）、中部、尾部的结点，实现方式都一样，执行以下三步操作：

  1. 找到目标元素所在结点的直接前驱结点；
  2. 将目标结点从链表中摘下来;
  3. 手动释放结点占用的内存空间；


从链表上摘除目标节点，只需找到该节点的直接前驱节点 temp，执行如下操作：

  1. temp->next=temp->next->next;

例如，从存有 {1,2,3,4} 的链表中删除存储元素 3 的结点，则此代码的执行效果如图 3 所示：


图 3 带头结点链表删除元素


实现代码如下：

  1. //p为原链表，elem 为要删除的目标元素
  2. int delElem(Link* p, int elem) {
  3. Link* del = NULL, *temp = p;
  4. int find = 0;
  5. //1、找到目标元素的直接前驱结点
  6. while (temp->next) {
  7. if (temp->next->elem == elem) {
  8. find = 1;
  9. break;
  10. }
  11. temp = temp->next;
  12. }
  13. if (find == 0) {
  14. return -1;//删除失败
  15. }
  16. else
  17. {
  18. //标记要删除的结点
  19. del = temp->next;
  20. //2、将目标结点从链表上摘除
  21. temp->next = temp->next->next;
  22. //3、释放目标结点
  23. free(del);
  24. return 1;
  25. }
  26. }


对于不带头结点的链表，需要单独考虑删除首元结点的情况，删除其它结点的方式和图 3 完全相同，如下图所示：


图 4 不带头结点链表删除结点


实现代码如下：

  1. //p为原链表，elem 为要删除的目标元素
  2. int delElem(Link** p, int elem) {
  3. Link* del = NULL, *temp = *p;
  4. //删除首元结点需要单独考虑
  5. if (temp->elem == elem) {
  6. (*p) = (*p)->next;
  7. free(temp);
  8. return 1;
  9. }
  10. else
  11. {
  12. int find = 0;
  13. //1、找到目标元素的直接前驱结点
  14. while (temp->next) {
  15. if (temp->next->elem == elem) {
  16. find = 1;
  17. break;
  18. }
  19. temp = temp->next;
  20. }
  21. if (find == 0) {
  22. return -1;//删除失败
  23. }
  24. else
  25. {
  26. //标记要删除的结点
  27. del = temp->next;
  28. //2、将目标结点从链表上摘除
  29. temp->next = temp->next->next;
  30. //3、释放目标结点
  31. free(del);
  32. return 1;
  33. }
  34. }
  35. }

函数返回 1 时，表示删除成功；返回 -1，表示删除失败。注意，该函数的形参 p 为二级指针，调用时需要传递链表头指针的地址。

链表查找元素

在链表中查找指定数据元素，最常用的方法是：从首元结点开始依次遍历所有节点，直至找到存储目标元素的结点。如果遍历至最后一个结点仍未找到，表明链表中没有存储该元素。

因此，链表中查找特定数据元素的 C 语言实现代码为：

  1. //p为原链表，elem表示被查找元素
  2. int selectElem(Link* p, int elem) {
  3. int i = 1;
  4. //带头结点，p 指向首元结点
  5. p = p->next;
  6. while (p) {
  7. if (p->elem == elem) {
  8. return i;
  9. }
  10. p = p->next;
  11. i++;
  12. }
  13. return -1;//返回-1，表示未找到
  14. }

注意第 5 行代码，对于有结点的链表，需要先将 p 指针指向首元结点；反之，对于不带头结点的链表，注释掉第 5 行代码即可。

链表更新元素

更新链表中的元素，只需通过遍历找到存储此元素的节点，对节点中的数据域做更改操作即可。

直接给出链表中更新数据元素的 C 语言实现代码：

  1. //p 为有头结点的链表，oldElem 为旧元素，newElem 为新元素
  2. int amendElem(Link* p, int oldElem, int newElem) {
  3. p = p->next;
  4. while (p) {
  5. if (p->elem == oldElem) {
  6. p->elem = newElem;
  7. return 1;
  8. }
  9. p = p->next;
  10. }
  11. return -1;
  12. }

函数返回 1，表示更改成功；返回数字 -1，表示更改失败。如果是没有头结点的链表，直接删除第 3 行代码即可。

总结

以上内容详细介绍了对链表中数据元素做"增删查改"的实现过程及 C 语言代码，最后给大家一段完整的代码，实现对有头结点链表的“增删查改”：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. //链表中节点的结构
  4. typedef struct link {
  5. int elem;
  6. struct link* next;
  7. }Link;
  8. Link* initLink() {
  9. int i;
  10. //1、创建头指针
  11. Link* p = NULL;
  12. //2、创建头结点
  13. Link* temp = (Link*)malloc(sizeof(Link));
  14. temp->elem = 0;
  15. temp->next = NULL;
  16. //头指针指向头结点
  17. p = temp;
  18. //3、每创建一个结点，都令其直接前驱结点的指针指向它
  19. for (i = 1; i < 5; i++) {
  20. //创建一个结点
  21. Link* a = (Link*)malloc(sizeof(Link));
  22. a->elem = i;
  23. a->next = NULL;
  24. //每次 temp 指向的结点就是 a 的直接前驱结点
  25. temp->next = a;
  26. //temp指向下一个结点（也就是a),为下次添加结点做准备
  27. temp = temp->next;
  28. }
  29. return p;
  30. }
  31. //p为链表，elem为目标元素，add为要插入的位置
  32. void insertElem(Link* p, int elem, int add) {
  33. int i;
  34. Link* c = NULL;
  35. Link* temp = p;//创建临时结点temp
  36. //首先找到要插入位置的上一个结点
  37. for (i = 1; i < add; i++) {
  38. temp = temp->next;
  39. if (temp == NULL) {
  40. printf("插入位置无效\n");
  41. return;
  42. }
  43. }
  44. //创建插入结点c
  45. c = (Link*)malloc(sizeof(Link));
  46. c->elem = elem;
  47. //① 将新结点的 next 指针指向插入位置后的结点
  48. c->next = temp->next;
  49. //② 将插入位置前结点的 next 指针指向插入结点；
  50. temp->next = c;
  51. }
  52. //p为原链表，elem 为要删除的目标元素
  53. int delElem(Link* p, int elem) {
  54. Link* del = NULL, *temp = p;
  55. int find = 0;
  56. //1、找到目标元素的直接前驱结点
  57. while (temp->next) {
  58. if (temp->next->elem == elem) {
  59. find = 1;
  60. break;
  61. }
  62. temp = temp->next;
  63. }
  64. if (find == 0) {
  65. return -1;//删除失败
  66. }
  67. else
  68. {
  69. //标记要删除的结点
  70. del = temp->next;
  71. //2、将目标结点从链表上摘除
  72. temp->next = temp->next->next;
  73. //3、释放目标结点
  74. free(del);
  75. return 1;
  76. }
  77. }
  78. //p为原链表，elem表示被查找元素
  79. int selectElem(Link* p, int elem) {
  80. int i = 1;
  81. //带头结点，p 指向首元结点
  82. p = p->next;
  83. while (p) {
  84. if (p->elem == elem) {
  85. return i;
  86. }
  87. p = p->next;
  88. i++;
  89. }
  90. return -1;//返回-1，表示未找到
  91. }
  92. //p 为有头结点的链表，oldElem 为旧元素，newElem 为新元素
  93. int amendElem(Link* p, int oldElem, int newElem) {
  94. p = p->next;
  95. while (p) {
  96. if (p->elem == oldElem) {
  97. p->elem = newElem;
  98. return 1;
  99. }
  100. p = p->next;
  101. }
  102. return -1;
  103. }
  104. //输出链表中各个结点的元素
  105. void display(Link* p) {
  106. p = p->next;
  107. while (p) {
  108. printf("%d ", p->elem);
  109. p = p->next;
  110. }
  111. printf("\n");
  112. }
  113. //释放链表
  114. void Link_free(Link* p) {
  115. Link* fr = NULL;
  116. while (p->next)
  117. {
  118. fr = p->next;
  119. p->next = p->next->next;
  120. free(fr);
  121. }
  122. free(p);
  123. }
  124. int main() {
  125. Link* p = initLink();
  126. printf("初始化链表为：\n");
  127. display(p);
  128. printf("在第 3 的位置上添加元素 6：\n");
  129. insertElem(p, 6, 3);
  130. display(p);
  131. printf("删除元素4：\n");
  132. delElem(p, 4);
  133. display(p);
  134. printf("查找元素 2：\n");
  135. printf("元素 2 的位置为：%d\n", selectElem(p, 2));
  136. printf("更改元素 1 的值为 6：\n");
  137. amendElem(p, 1, 6);
  138. display(p);
  139. Link_free(p);
  140. return 0;
  141. }

执行结果为：

初始化链表为：
1 2 3 4
在第 3 的位置上添加元素 6：
1 2 6 3 4
删除元素4：
1 2 6 3
查找元素 2：
元素 2 的位置为：2
更改元素 1 的值为 6：
6 2 6 3

 

标签：结点,单链,temp,int,及其,elem,next,链表,基本操作
From： https://www.cnblogs.com/suishou/p/16808551.html

相关文章

  • 双向链表及其基本操作
    虽然单链表能100%存储逻辑关系为"一对一"的数据，但在解决某些实际问题时，单链表的执行效率并不高。例如，若实际问题中需要频繁地查找某个结点的前驱结点，使用单链表存储数......
  • 循环链表及其基本操作
    1.循环链表概念对于单链表以及双向链表，其就像一个小巷，无论怎么样最终都能从一端走到另一端，然而循环链表则像一个有传送门的小巷，因为循环链表当你以为你走到结尾的时候，其......
  • 静态链表及基本操作
    我们了解了两种存储结构各自的特点，那么，是否存在一种存储结构，可以融合顺序表和链表各自的优点，从而既能快速访问元素，又能快速增加或删除数据元素。静态链表，也是线性存储结构......
  • JDBC的增删改查基本操作
    packageJDBC_1;//演示jdbc所使用的预编译importjava.sql.*;publicclassjdbc_2{privatestaticConnectioncoon=null;static{try{Cl......
  • STM32的优先级的理解及其使用
     有组0~4。同时对每一个中断设置一个抢占优先级和一个响应优先级值。分组配置是在寄存器SCB->AIRCR中配置：SCB->AIRCR为111，就是0位抢占，4位响应中断优先级表格  NVI......
  • GRU原理及其实现
    title:GRU原理及其实现date:2022-10-0309:31:44mathjax:truetags:GRUGRU原理及其实现https://www.bilibili.com/video/BV1jm4y1Q7uh/?spm_id_from=333.788&v......
  • 【Python】第3章-7 求最大值及其下标
    本题要求编写程序，找出给定的n个数中的最大值及其对应的最小下标（下标从0开始）。输入格式:输入在第一行中给出一个正整数n（1<n≤10）。第二行输入n个整数，用空格分开。输出格式......
  • （面向对象）已知长方形类Rectangle,在构造方法中有私有实例变量宽__width和高__height，有a
    样例输入34 样例输出3*4=124*5=20未定义宽,未定义高 样例输入67 样例输出6*7=427*8=56未定义宽,未定义高 解题代码#coding=gbkclassRec......
  • linux驱动开发FL2440开发板-LED驱动及其测试程序
    ———————————————————————————————————————主机操作系统：Centos6.7交叉编译器环境：arm-linux-gcc-4.5.4 开发板平台：FL2440 Linu......
  • 循环单链表的创建，头插法、尾插法——基于C语言数据结构
    #include<stdio.h>#include<malloc.h>typedefintElemType;typedefstructLNode{ElemTypedata;structLNode*next;}CLinkNode;voidInitList(CLinkN......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99