1. #include <stdio.h>
    2. #include <stdlib.h>
    3. typedef struct line {
    4.     struct line * prior;
    5.     int data;
    6.     struct line * next;
    7. }line;
    8. //双链表的创建
    9. line* initLine(line * head);
    10. //双链表插入元素，add表示插入位置
    11. line * insertLine(line * head, int data, int add);
    12. //双链表删除指定元素
    13. line * delLine(line * head, int data);
    14. //双链表中查找指定元素
    15. int selectElem(line * head, int elem);
    16. //双链表中更改指定位置节点中存储的数据，add表示更改位置
    17. line *amendElem(line * p, int add, int newElem);
    18. //输出双链表的实现函数
    19. void display(line * head);
    20. int main() {
    21.     line * head = NULL;
    22.     //创建双链表
    23.     printf("初始链表为：\n");
    24.     head = initLine(head);
    25.     display(head);
    26.     //在表中第 3 的位置插入元素 7
    27.     printf("在表中第 3 的位置插入新元素 7：\n");
    28.     head = insertLine(head, 7, 3);
    29.     display(head);
    30.     //表中删除元素 2
    31.     printf("删除元素 2：\n");
    32.     head = delLine(head, 2);
    33.     display(head);
    35.     printf("元素 3 的位置是：%d\n", selectElem(head, 3));
    36.     //表中第 3 个节点中的数据改为存储 6
    37.     printf("将第 3 个节点存储的数据改为 6：\n");
    38.     head = amendElem(head, 3, 6);
    39.     display(head);
    40.     return 0;
    41. }
    42. line* initLine(line * head) {
    43.     int i = 0;
    44.     line * list = NULL;
    45.     //从内存中申请一片内存
    46.     head = (line*)malloc(sizeof(line));
    47.     //初始化
    48.     head->prior = NULL;
    49.     head->next = NULL;
    50.     head->data = 1;
    51.     //我们需要保证head的位置不变，所以连接链表由list执行
    52.     list = head;
    54.     for (i = 2; i <= 3; i++) {
    55.         //创建链表体
    56.         line * body = (line*)malloc(sizeof(line));
    57.         body->prior = NULL;
    58.         body->next = NULL;
    59.         //i=2， 3
    60.         body->data = i;
    61.         //让链表的头下一个元素指向体
    62.         list->next = body;
    63.         body->prior = list;
    64.         list = list->next;
    65.         /*
    66.             list = head; 
    67.             head ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    68.             create body
    69.             list->next = body;
    71.             head
    72.             list -> body ~~~~~~~~~~~~~~~~~~~~~~~~
    74.             body->prior = list'
    76.             head
    77.             list <- -> body ~~~~~~~~~~~~~~~
    79.             list - >next = body;
    80.                     list
    81.             head -> body ~~~~~~~~~~~~~~~~
    83.         */
    85.     }
    86.     return head;
    87. }
    88. line * insertLine(line * head, int data, int add) {
    89.     //新建数据域为data的结点
    90.     line * temp = (line*)malloc(sizeof(line));
    91.     temp->data = data;
    92.     temp->prior = NULL;
    93.     temp->next = NULL;
    94.     //插入到链表头，要特殊考虑
    95.     if (add == 1) {
    96.         temp->next = head;
    97.         head->prior = temp;
    98.         head = temp;
    99.     }
    100.     else {
    101.         int i = 0;
    102.         line * body = head;
    103.         //找到要插入位置的前一个结点
    104.         for (i = 1; i < add - 1; i++) {
    105.             body = body->next;
    106.             if (body == NULL) {
    107.                 printf("插入位置有误\n");
    108.                 break;
    109.             }
    110.         }
    111.         if (body) {
    112.             //判断条件为真，说明插入位置为链表尾
    113.             if (body->next == NULL) {
    114.                 body->next = temp;
    115.                 temp->prior = body;
    116.             }
    117.             else {
    118.                 body->next->prior = temp;
    119.                 temp->next = body->next;
    120.                 body->next = temp;
    121.                 temp->prior = body;
    122.             }
    123.         }
    124.     }
    125.     return head;
    126. }
    127. line * delLine(line * head, int data) {
    128.     line * temp = head;
    129.     //遍历链表
    130.     while (temp) {
    131.         //判断当前结点中数据域和data是否相等，若相等，摘除该结点
    132.         if (temp->data == data) {
    133.             temp->prior->next = temp->next;
    134.             temp->next->prior = temp->prior;
    135.             free(temp);
    136.             return head;
    137.         }
    138.         temp = temp->next;
    139.     }
    140.     printf("链表中无该数据元素\n");
    141.     return head;
    142. }
    143. //head为原双链表，elem表示被查找元素
    144. int selectElem(line * head, int elem) {
    145.     //新建一个指针t，初始化为头指针 head
    146.     line * t = head;
    147.     int i = 1;
    148.     while (t) {
    149.         if (t->data == elem) {
    150.             return i;
    151.         }
    152.         i++;
    153.         t = t->next;
    154.     }
    155.     //程序执行至此处，表示查找失败
    156.     return -1;
    157. }
    158. //更新函数，其中，add 表示更改结点在双链表中的位置，newElem 为新数据的值
    159. line *amendElem(line * p, int add, int newElem) {
    160.     int i = 0;
    161.     line * temp = p;
    162.     //遍历到被删除结点
    163.     for (i = 1; i < add; i++) {
    164.         temp = temp->next;
    165.         if (temp == NULL) {
    166.             printf("更改位置有误！\n");
    167.             break;
    168.         }
    169.     }
    170.     if (temp) {
    171.         temp->data = newElem;
    172.     }
    173.     return p;
    174. }
    175. //输出链表的功能函数
    176. void display(line * head) {
    177.     line * temp = head;
    178.     while (temp) {
    179.         if (temp->next == NULL) {
    180.             printf("%d\n", temp->data);
    181.         }
    182.         else {
    183.             printf("%d->", temp->data);
    184.         }
    185.         temp = temp->next;
    186.     }
    187. }