码迷，mamicode.com
首页 > 编程语言 > 详细

数据结构与算法02--链表基础

时间：2016-04-21 11:50:04      阅读：260      评论：0      收藏：0      [点我收藏+]

标签：

1双向线性链表

1.1 问题

双向线性链表是采用链式存储的方式存储的线性表。链式存储结构是由一系列结点（链表中每一个元素称为结点）组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储当前结点的前驱结点和后继结点地址的指针域，结点是在有数据时动态生成的，是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

1.2 方案

双向线性链表的基本操作包括：

1) 初始化操作，在初始化操作中将双向线性链表的头指针指空。

2) 求表长，求表长操作是计算出双向线性链表中结点的个数。

3) 取双向线性链表中指定位置的结点，即给定双向线性链表中的第几个结点，求其值。

4) 查找结点，在双向线性链表中查找值为x的结点，并返回该结点在双向线性链表中的位置。若双向线性链表中有多个结点的值和x相同，则返回首次找到的结点位；若双向线性链表中没有结点的值为x，则返回一个NULL表示查找失败。

5) 插入结点，在双向线性链表的第i个结点前插入一个值为x的新结点。

6) 删除结点，删除双向线性链表的第i个结点。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义双向线性链表

在C语言中：

1)定义一个变量来表示双向线性链表中某个结点的数据。

2)定义两个指针来表示该结点的前驱结点和后继结点的地址。

3)这两方面的信息共同描述一个双向线性链表的结点，可将它们封装在一起。

代码如下所示：

  1. typedef int DataType;
  2. struct Node{
  3.     DataType data;
  4.     struct Node *pre, *next;
  5. };

上述代码中，以下代码：

  1. typedef int DataType;

是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当双向线性链表中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

上述代码中，以下代码：

  1.     struct Node *pre, *next;

分别定义了当前结点的前驱指针和后继指针。因为当前结点的前驱结点和后继结点都是双向线性链表的结点数据类型，所以前驱指针和后继指针也是struct Node *类型。

步骤二：初始化操作

在主程序中，定义双向线性链表的头指针。

在初始化函数中将头指针初始化为NULL，表示为空表。

代码如下所示：

  1. void init(struct Node** head)
  2. {
  3.     *head = NULL;
  4. }
  5. int main()
  6. {
  7.     
  8.     //头指针
  9.     struct Node *headList;
  10.     init(&headList);
  11.     
  12. }

步骤三：求表长

求表长即求双向线性链表中结点的个数，结点的个数是通过遍历链表并统计结点个数得到的。

代码如下所示：

  1. int getSize(struct Node* head)
  2. {
  3.     struct Node* p = head;
  4.     int count = 0;
  5.     while(p)
  6.     {
  7.         count ++;
  8.         p = p->next;
  9.     }
  10.     return count;
  11. }

步骤四：取链表中指定位置的数据元素

首先，判断要查找的是否为头结点。

然后，遍历链表，确定要查找的结点位置。

代码如下：

  1. struct Node* getptr(struct Node* head, int pos) {
  2.     struct Node *p = head;
  3.     if (p == 0 || pos == 0) {
  4.         return head;
  5.     }
  6.     for(int i = 0; p && i < pos; i++) {
  7.         p = p->next;
  8.     }
  9.     return p;
  10. }

步骤五：插入结点

首先，判断要插入的结点位置是否正确。

然后，创建结点。

最后，插入结点，插入时分两种情况处理：一种是插入到第一个结点前面，另一种是插入到链表中间。

  1. //指定位置 插入元素
  2. bool insert(struct Node** head, int position, DataType d) {
  3.     if (position < 0 || position > getSize(*head)) {
  4.         return false;
  5.     }
  6.     //创建 节点
  7.     struct Node *node = (struct Node*)malloc(sizeof(struct Node));
  8.     node->data = d;
  9.     node->pre = NULL;
  10.     node->next = NULL;
  11.     
  12.     //插入到第一个节点的前面
  13.     if (position == 0) {
  14.         node->next = *head;
  15.         if (*head != NULL)
  16.             (*head)->pre = node;
  17.         *head = node;
  18.         return true;
  19.     }
  20.     
  21.     //插入到链表的中间
  22.     struct Node *p = getptr(*head, position - 1);
  23.     struct Node* r = p->next;
  24.     node->next = r;
  25.     r->pre = node;
  26.     p->next = node;
  27.     node->pre = p;
  28.     
  29.     return true;
  30. }

上述代码中，以下代码：

  1.         if (*head != NULL)
  2.             (*head)->pre = node;

是判断头指针是否为空，如果不为空，则头指针指向的结点的前驱指针指向新加入的结点。

上述代码中，以下代码：

  1.     node->next = r;
  2.     r->pre = node;
  3.     p->next = node;
  4.     node->pre = p;

node为要插入的新结点，插入到p和r指向的结点之间，所以node的后继结点指针指向r，r的前驱结点指针指向node，node的前驱指针指向p，p的后继指针指向node。

步骤六：删除节点

首先，判断要删除的结点位置是否正确。

然后，删除结点，删除时分两种情况处理：一种是删除第一个结点，另一种是删除链表的中间结点。

最后，释放被删除结点所占有的存储空间。

代码如下：

  1. //删除指定位置元素
  2. bool erases(struct Node** head, int pos) {
  3.     if (pos < 0 || pos >= getSize(*head))
  4.         return false;
  5.     
  6.     //删除第一个结点
  7.     struct Node *p = *head;
  8.     if (pos == 0) {
  9.         *head = (*head)->next;
  10.         if (*head != NULL)
  11.             (*head)->pre = NULL;
  12.         free(p);
  13.         p = NULL;
  14.         return true;
  15.     }
  16.     
  17.     //删除链表的中间结点
  18.     p = getptr(*head, pos - 1);
  19.     struct Node *q = p->next;
  20.     p->next = q->next;
  21.     q->next->pre = p;
  22.     free(q);
  23.     q = NULL;
  24.     
  25.     return true;
  26. }

上述代码中，以下代码：

  1.         if (*head != NULL)
  2.             (*head)->pre = NULL;

是删除链表的头结点后，如果头指针不为空，即链表中还有结点，则让新的头结点的前驱指针为空。

上述代码中，以下代码：

  1.     p->next = q->next;
  2.     q->next->pre = p;

p指向要删除结点的前一结点，q指向要删除的结点，此时只需要让p由指向q，改为指向q的后继结点；让q的后继结点的前驱指针由指向q，改为指向p，即可将要删除的结点q从链表中断开，从而达到删除的目的。

步骤七：修改结点中数据

首先，判断要修改的结点是否在链表内。

然后，找到要修改的结点的位置。

最后，修改结点的数据。

  1. //修改指定位置 元素
  2. bool set(struct Node* head, int pos, DataType d) {
  3.     if (pos < 0 || pos >= getSize(head)) {
  4.         return false;
  5.     }
  6.     struct Node *p = getptr(head, pos);
  7.     p->data = d;
  8.     return true;
  9. }

步骤八：删除链表

首先，遍历整个链表。

然后，逐个释放链表中每个结点。

  1. void clears(struct Node* head) {
  2.     while (head) {
  3.         struct Node *p = head->next;
  4.         free(head);
  5.         head = p;
  6.     }
  7. }

3.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <stdbool.h>
  3. #include <stdlib.h>
  5. typedef int DataType;
  6. struct Node{
  7.     DataType data;
  8.     struct Node *pre, *next;
  9. };
  11. void init(struct Node** head)
  12. {
  13.     *head = NULL;
  14. }
  16. int getSize(struct Node* head)
  17. {
  18.     struct Node* p = head;
  19.     int count = 0;
  20.     while(p)
  21.     {
  22.         count ++;
  23.         p = p->next;
  24.     }
  25.     return count;
  26. }
  28. //找到指定位置 元素地址
  29. struct Node* getptr(struct Node* head, int pos) {
  30.     struct Node *p = head;
  31.     if (p == 0 || pos == 0) {
  32.         return head;
  33.     }
  34.     for(int i = 0; p && i < pos; i++) {
  35.         p = p->next;
  36.     }
  37.     return p;
  38. }
  40. //指定位置 插入元素
  41. bool insert(struct Node** head, int position, DataType d) {
  42.     if (position < 0 || position > getSize(*head)) {
  43.         return false;
  44.     }
  45.     //创建 节点
  46.     struct Node *node = (struct Node*)malloc(sizeof(struct Node));
  47.     node->data = d;
  48.     node->pre = NULL;
  49.     node->next = NULL;
  50.     
  51.     //插入到第一个节点的前面
  52.     if (position == 0) {
  53.         node->next = *head;
  54.         if (*head != NULL)
  55.             (*head)->pre = node;
  56.         *head = node;
  57.         return true;
  58.     }
  59.     
  60.     //插入到链表的中间
  61.     struct Node *p = getptr(*head, position - 1);
  62.     struct Node* r = p->next;
  63.     node->next = r;
  64.     r->pre = node;
  65.     p->next = node;
  66.     node->pre = p;
  67.     
  68.     return true;
  69. }
  71. //删除指定位置元素
  72. bool erases(struct Node** head, int pos) {
  73.     if (pos < 0 || pos >= getSize(*head))
  74.         return false;
  75.     
  76.     //删除第一个结点
  77.     struct Node *p = *head;
  78.     if (pos == 0) {
  79.         *head = (*head)->next;
  80.         if (*head != NULL)
  81.             (*head)->pre = NULL;
  82.         free(p);
  83.         p = NULL;
  84.         return true;
  85.     }
  86.     
  87.     //删除链表的中间结点
  88.     p = getptr(*head, pos - 1);
  89.     struct Node *q = p->next;
  90.     p->next = q->next;
  91.     q->next->pre = p;
  92.     free(q);
  93.     q = NULL;
  94.     
  95.     return true;
  96. }
  98. //修改指定位置 元素
  99. bool set(struct Node* head, int pos, DataType d) {
  100.     if (pos < 0 || pos >= getSize(head)) {
  101.         return false;
  102.     }
  103.     struct Node *p = getptr(head, pos);
  104.     p->data = d;
  105.     return true;
  106. }
  108. //清理 链表
  109. void clears(struct Node* head) {
  110.     while (head) {
  111.         struct Node *p = head->next;
  112.         free(head);
  113.         head = p;
  114.     }
  115. }
  118. //打印
  119. void print(struct Node* head) {
  120.     struct Node *p = head;
  121.     while (p) {
  122.         printf("%d ", p->data);
  123.         p = p->next;
  124.     }
  125.     printf("\n");
  126. }
  128. int main()
  129. {
  130.     
  131.     //头指针
  132.     struct Node *headList;
  133.     init(&headList);
  134.     
  135.     insert(&headList, 0, 10);
  136.     insert(&headList, 0, 20);
  137.     insert(&headList, 0, 30);
  138.     insert(&headList, 2, 40);
  139.     insert(&headList, 2, 50);
  140.     insert(&headList, 0, 60);
  141.     insert(&headList, 0, 80);
  142.     print(headList);
  143.     erases(&headList, 1);
  144.     print(headList);
  145.     set(headList, 0, 100);
  146.     set(headList, 0, 110);
  147.     print(headList);
  148.     
  149.     return 0;
  150. }

4 单向线性链表

4.1 问题

单向线性链表是采用链式存储的方式存储的线性表。链式存储结构是由一系列结点（链表中每一个元素称为结点）组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域，结点是在有数据时动态生成的，是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

4.2 方案

链表的基本操作包括：

1) 初始化操作，在初始化操作中将单向线性链表的头指针指空。

2) 求表长，求表长操作是计算出单向线性链表中结点的个数。

3) 取单向线性链表中指定位置的结点，即给定链表中的第几个结点，求其值。

4) 查找结点，在单向线性链表中查找值为x的结点，并返回该结点在单向线性链表中的位置。若单向线性链表中有多个结点的值和x相同，则返回首次找到的结点位；若单向线性链表中没有结点的值为x，则返回一个NULL表示查找失败。

5) 插入结点，在单向线性链表的第i个结点前插入一个值为x的新结点。

6) 删除结点，删除单向线性链表的第i个结点。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义单向线性链表

在C语言中：

1)定义一个变量来表示单向线性链表中某个结点的数据。

2)定义一个指针来表示该结点的后继结点的地址。

3)这两方面的信息共同描述一个单向线性链表的结点，可将它们封装在一起。

代码如下所示：

  1. typedef int DataType;
  2. struct Node{
  3.     DataType data;
  4.     struct Node *next;
  5. };

上述代码中，以下代码：

  1. typedef int DataType;

是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当链表中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

步骤二：初始化操作

在主程序中，定义链表的头指针。

在初始化函数中将头指针初始化为NULL，表示为空表。

代码如下所示：

  1. void init(struct Node** head)
  2. {
  3.     *head = NULL;
  4. }
  5. int main()
  6. {
  7.     
  8.     //头指针
  9.     struct Node *headList;
  10.     init(&headList);
  11.     
  12. }

步骤三：求表长

求表长即求链表中结点的个数，结点的个数是通过遍历链表并统计结点个数得到的。

代码如下所示：

  1. int getSize(struct Node* head)
  2. {
  3.     struct Node* p = head;
  4.     int count = 0;
  5.     while(p)
  6.     {
  7.         count ++;
  8.         p = p->next;
  9.     }
  10.     return count;
  11. }

步骤四：取链表中指定位置的数据元素

首先，判断要查找的是否为头结点。

然后，遍历链表，确定要查找的结点位置。

代码如下：

  1. struct Node* getptr(struct Node* head, int pos) {
  2.     struct Node *p = head;
  3.     if (p == 0 || pos == 0) {
  4.         return head;
  5.     }
  6.     for(int i = 0; p && i < pos; i++) {
  7.         p = p->next;
  8.     }
  9.     return p;
  10. }

步骤五：插入结点

首先，判断要插入的结点位置是否正确。

然后，创建结点。

最后，插入结点，插入时分两种情况处理：一种是插入到第一个结点前面，另一种是插入到链表中间。

  1. bool insert(struct Node** head, int position, DataType d) {
  2.     if (position < 0 || position > getSize(*head)) {
  3.         return false;
  4.     }
  5.     //创建 节点
  6.     struct Node *node = (struct Node*)malloc(sizeof(struct Node));
  7.     node->data = d;
  8.     node->next = NULL;
  9.     
  10.     //插入到第一个节点的前面
  11.     if (position == 0) {
  12.         node->next = *head;
  13.         *head = node;
  14.         return true;
  15.     }
  16.     
  17.     //插入到链表的中间
  18.     struct Node *p = getptr(*head, position - 1);
  19.     struct Node* r = p->next;
  20.     node->next = r;
  21.     p->next = node;
  22.     
  23.     return true;
  24. }

步骤六：删除节点

首先，判断要删除的结点位置是否正确。

然后，删除结点，删除时分两种情况处理：一种是删除第一个结点，另一种是删除链表的中间结点。

最后，释放被删除结点所占有的存储空间。

代码如下：

  1. bool erases(struct Node** head, int pos) {
  2.     if (pos < 0 || pos >= getSize(*head))
  3.         return false;
  4.     struct Node *p = *head;
  5.     if (pos == 0) {
  6.         *head = (*head)->next;
  7.         free(p);
  8.         p = NULL;
  9.         return true;
  10.     }
  11.     p = getptr(*head, pos - 1);
  12.     struct Node *q = p->next;
  13.     p->next = q->next;
  14.     free(q);
  15.     q = NULL;
  16.     
  17.     return true;
  18. }

步骤七：修改结点中数据

首先，判断要修改的结点是否在链表内。

然后，找到要修改的结点的位置。

最后，修改结点的数据。

  1. bool set(struct Node* head, int pos, DataType d) {
  2.     if (pos < 0 || pos >= getSize(head)) {
  3.         return false;
  4.     }
  5.     struct Node *p = getptr(head, pos);
  6.     p->data = d;
  7.     return true;
  8. }

步骤八：删除链表

首先，遍历整个链表。

然后，逐个释放链表中每个结点。

  1. void clears(struct Node* head) {
  2.     while (head) {
  3.         struct Node *p = head->next;
  4.         free(head);
  5.         head = p;
  6.     }
  7. }

4.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <stdbool.h>
  3. #include <stdlib.h>
  5. typedef int DataType;
  6. struct Node{
  7.     DataType data;
  8.     struct Node *next;
  9. };
  11. void init(struct Node** head)
  12. {
  13.     *head = NULL;
  14. }
  16. int getSize(struct Node* head)
  17. {
  18.     struct Node* p = head;
  19.     int count = 0;
  20.     while(p)
  21.     {
  22.         count ++;
  23.         p = p->next;
  24.     }
  25.     return count;
  26. }
  28. //找到指定位置 元素地址
  29. struct Node* getptr(struct Node* head, int pos) {
  30.     struct Node *p = head;
  31.     if (p == 0 || pos == 0) {
  32.         return head;
  33.     }
  34.     for(int i = 0; p && i < pos; i++) {
  35.         p = p->next;
  36.     }
  37.     return p;
  38. }
  40. //指定位置 插入元素
  41. bool insert(struct Node** head, int position, DataType d) {
  42.     if (position < 0 || position > getSize(*head)) {
  43.         return false;
  44.     }
  45.     //创建 节点
  46.     struct Node *node = (struct Node*)malloc(sizeof(struct Node));
  47.     node->data = d;
  48.     node->next = NULL;
  49.     
  50.     //插入到第一个节点的前面
  51.     if (position == 0) {
  52.         node->next = *head;
  53.         *head = node;
  54.         return true;
  55.     }
  56.     
  57.     //插入到链表的中间
  58.     struct Node *p = getptr(*head, position - 1);
  59.     struct Node* r = p->next;
  60.     node->next = r;
  61.     p->next = node;
  62.     
  63.     return true;
  64. }
  66. //删除指定位置元素
  67. bool erases(struct Node** head, int pos) {
  68.     if (pos < 0 || pos >= getSize(*head))
  69.         return false;
  70.     struct Node *p = *head;
  71.     if (pos == 0) {
  72.         *head = (*head)->next;
  73.         free(p);
  74.         p = NULL;
  75.         return true;
  76.     }
  77.     p = getptr(*head, pos - 1);
  78.     struct Node *q = p->next;
  79.     p->next = q->next;
  80.     free(q);
  81.     q = NULL;
  82.     
  83.     return true;
  84. }
  86. //修改指定位置 元素
  87. bool set(struct Node* head, int pos, DataType d) {
  88.     if (pos < 0 || pos >= getSize(head)) {
  89.         return false;
  90.     }
  91.     struct Node *p = getptr(head, pos);
  92.     p->data = d;
  93.     return true;
  94. }
  96. //清理 链表
  97. void clears(struct Node* head) {
  98.     while (head) {
  99.         struct Node *p = head->next;
  100.         free(head);
  101.         head = p;
  102.     }
  103. }
  106. //打印
  107. void print(struct Node* head) {
  108.     struct Node *p = head;
  109.     while (p) {
  110.         printf("%d ", p->data);
  111.         p = p->next;
  112.     }
  113.     printf("\n");
  114. }
  116. int main()
  117. {
  118.     
  119.     //头指针
  120.     struct Node *headList;
  121.     init(&headList);
  122.     
  123.     insert(&headList, 0, 10);
  124.     insert(&headList, 0, 20);
  125.     insert(&headList, 0, 30);
  126.     insert(&headList, 2, 40);
  127.     insert(&headList, 2, 50);
  128.     insert(&headList, 0, 60);
  129.     insert(&headList, 0, 80);
  130.     print(headList);
  131.     erases(&headList, 0);
  132.     print(headList);
  133.     set(headList, 0, 100);
  134.     set(headList, 0, 110);
  135.     print(headList);
  136.     
  137.     return 0;
  138. }

















数据结构与算法02--链表基础

标签：

原文地址：http://blog.csdn.net/opera95/article/details/51205918
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！