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

    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("
");
    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("
");
    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. }
  • 相关阅读:
    2016-06-06：X264码率控制
    2016-04-12：图像差异查找算法
    2016-03-24：Windows内存泄露分析工具
    2016-03-15:关于VS中模块定义文件
    2016-03-10：libx265源码解析
    MSSQL字符串取相应的第几个数组值
    MSSQL字符串分割
    list 属性字段直接转成字符串数组
    WebApiTestClient
    获取文件路径
  • 原文地址：https://www.cnblogs.com/lxjshuju/p/7397751.html
Copyright © 2020-2023  润新知