22.双向链表增删查改

  • 双链表结点 
    //双链表节点
typedef struct LinkNode
{
    int data;
    struct LinkNode *pPre;
    struct LinkNode *pNext;
}node;
  • 创建一个结构体保存双链表的头和尾 
    1 typedef struct info
2 {
3     node *head;//指向头部
4     node *tail;//指向尾部
5 }List;
  • 初始化List 
    1 void init(List *p)
2 {
3     p->head = NULL;
4     p->tail = NULL;
5 }
  • 在链表头部插入数据 
     1 void addDataHead(List *p, int data)
 2 {
 3     node *pnew = (node *)malloc(sizeof(node));
 4     pnew->data = data;
 5     pnew->pNext = NULL;
 6     pnew->pPre = NULL;
 7 
 8     if (p->head == NULL || p->tail == NULL)
 9     {
10         //插入一个结点
11         p->head = pnew;
12         p->tail = pnew;
13     }
14     else
15     {
16         p->head->pPre = pnew;//前驱
17         pnew->pNext = p->head;//后继
18         p->head = pnew;//插入,头插
19     }
20 }
  • 在链表尾部插入数据 
     1 void addDataBack(List *p, int data)
 2 {
 3     node *pnew = (node *)malloc(sizeof(node));
 4     pnew->data = data;
 5     pnew->pNext = NULL;
 6     pnew->pPre = NULL;
 7 
 8     if (p->head == NULL || p->tail == NULL)
 9     {
10         //插入一个结点
11         p->head = pnew;
12         p->tail = pnew;
13     }
14     else
15     {
16         p->tail->pNext = pnew;
17         pnew->pPre = p->tail;
18         p->tail = pnew;
19     }
20 }
  • 显示链表的数据 
     1 void show(List *p)
 2 {
 3     node *pshow = p->head;
 4     while (pshow != NULL)
 5     {
 6         printf("%4d", pshow->data);
 7         pshow = pshow->pNext;
 8     }
 9     printf("
");
10 }
  • 反向显示链表的数据 
     1 void revshow(List *p)
 2 {
 3     node *pshow = p->tail;
 4     while (pshow != NULL)
 5     {
 6         printf("%4d", pshow->data);
 7         pshow = pshow->pPre;
 8     }
 9     printf("
");
10 }
  • 链表中查找数据 
     1 node* find(List *p,int data)
 2 {
 3     node *ptmp = p->head;
 4     while (ptmp != NULL)
 5     {
 6         if (ptmp->data == data)
 7         {
 8             return ptmp;
 9         }
10         ptmp = ptmp->pNext;
11     }
12     return NULL;
13 }
  • 反向查找 
     1 node* revfind(List *p, int data)
 2 {
 3     node *ptmp = p->tail;
 4     while (ptmp != NULL)
 5     {
 6         if (ptmp->data == data)
 7         {
 8             return ptmp;
 9         }
10         ptmp = ptmp->pPre;
11     }
12     return NULL;
13 }
  • 在指定数据之前插入数据 
     1 void insertdata(List *p, int data, int newdata)
 2 {
 3     node *pnew = (node *)malloc(sizeof(node));
 4     pnew->data = newdata;
 5     pnew->pNext = NULL;
 6     pnew->pPre = NULL;
 7 
 8     //p1记录找到的位置
 9     node *p1 = NULL;
10     p1 = p->head;
11     while (p1 != NULL)
12     {
13         if (p1->data != data)
14         {
15             p1 = p1->pNext;
16         }
17         else
18         {
19             break;
20         }
21     }
22     //中间情况
23     if (p1 != p->head && p1 != p->tail)
24     {
25         pnew->pNext = p1;
26         pnew->pPre = p1->pPre;
27 
28         p1->pPre->pNext = pnew;
29         p1->pNext->pPre = pnew;
30     }
31     else if (p1 == p->head)
32     {
33         pnew->pNext = p1;
34         p1->pPre = pnew;
35         p->head = pnew;
36 
37     }
38     else if (p1 == p->tail)
39     {
40         pnew->pNext = p1;
41         pnew->pPre = p1->pPre;
42 
43         p1->pPre->pNext = pnew;
44         p1->pPre = pnew;
45     }
46 }
  • 删除指定数据 
     1 void deletedata(List *p, int data)
 2 {
 3     //p1遍历循环查找位置
 4     node *p1 = NULL;
 5     p1 = p->head;
 6     while (p1 != NULL)
 7     {
 8         if (p1->data == data)
 9         {
10             p1 = p1->pNext ;
11         }
12         else
13         {
14             break;
15         }
16     }
17     //p1记录找到的位置
18     //中间情况
19     if (p1 != p->head && p1 != p->tail)
20     {
21         p1->pPre->pNext = p1->pNext;
22         p1->pNext->pPre = p1->pPre;
23         free(p1);
24     }
25     else if (p1 == p->head)
26     {
27         p->head = p1->pNext;
28         p1->pNext->pPre = NULL;
29         free(p1);
30     }
31     else if (p1 == p->tail)
32     {
33         p->tail = p1->pPre;
34         p1->pPre->pNext = NULL;
35         free(p1);
36     }
37 }
  • main函数 
     1 void main()
 2 {
 3     List dList;
 4     init(&dList);
 5     addDataHead(&dList,1);
 6     addDataHead(&dList, 2);
 7     addDataHead(&dList, 3);
 8     addDataHead(&dList, 4);
 9     addDataHead(&dList, 5);
10     //addDataBack(&dList, 10);
11     insertdata(&dList, 4, 939);
12     show(&dList);
13     /*revshow(&dList);
14     node *pfind = find(&dList, 3);
15     pfind->data = 12;
16     show(&dList);*/
17     /*deletedata(&dList, 3);
18     show(&dList);*/
19     system("pause");
20 }

完整代码:

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 //双链表节点
  5 typedef struct LinkNode
  6 {
  7     int data;
  8     struct LinkNode *pPre;
  9     struct LinkNode *pNext;
 10 }node;
 11 
 12 typedef struct info
 13 {
 14     node *head;//指向头部
 15     node *tail;//指向尾部
 16 }List;
 17 
 18 void init(List *p)
 19 {
 20     p->head = NULL;
 21     p->tail = NULL;
 22 }
 23 
 24 //在链表头部插入数据
 25 void addDataHead(List *p, int data)
 26 {
 27     node *pnew = (node *)malloc(sizeof(node));
 28     pnew->data = data;
 29     pnew->pNext = NULL;
 30     pnew->pPre = NULL;
 31 
 32     if (p->head == NULL || p->tail == NULL)
 33     {
 34         //插入一个结点
 35         p->head = pnew;
 36         p->tail = pnew;
 37     }
 38     else
 39     {
 40         p->head->pPre = pnew;//前驱
 41         pnew->pNext = p->head;//后继
 42         p->head = pnew;//插入,头插
 43     }
 44 }
 45 
 46 //在链表尾部插入数据
 47 void addDataBack(List *p, int data)
 48 {
 49     node *pnew = (node *)malloc(sizeof(node));
 50     pnew->data = data;
 51     pnew->pNext = NULL;
 52     pnew->pPre = NULL;
 53 
 54     if (p->head == NULL || p->tail == NULL)
 55     {
 56         //插入一个结点
 57         p->head = pnew;
 58         p->tail = pnew;
 59     }
 60     else
 61     {
 62         p->tail->pNext = pnew;
 63         pnew->pPre = p->tail;
 64         p->tail = pnew;
 65     }
 66 }
 67 
 68 //显示链表的数据
 69 void show(List *p)
 70 {
 71     node *pshow = p->head;
 72     while (pshow != NULL)
 73     {
 74         printf("%4d", pshow->data);
 75         pshow = pshow->pNext;
 76     }
 77     printf("
");
 78 }
 79 
 80 //反向显示链表的数据
 81 
 82 void revshow(List *p)
 83 {
 84     node *pshow = p->tail;
 85     while (pshow != NULL)
 86     {
 87         printf("%4d", pshow->data);
 88         pshow = pshow->pPre;
 89     }
 90     printf("
");
 91 }
 92 
 93 //链表中查找数据
 94 node* find(List *p,int data)
 95 {
 96     node *ptmp = p->head;
 97     while (ptmp != NULL)
 98     {
 99         if (ptmp->data == data)
100         {
101             return ptmp;
102         }
103         ptmp = ptmp->pNext;
104     }
105     return NULL;
106 }
107 
108 //反向查找
109 node* revfind(List *p, int data)
110 {
111     node *ptmp = p->tail;
112     while (ptmp != NULL)
113     {
114         if (ptmp->data == data)
115         {
116             return ptmp;
117         }
118         ptmp = ptmp->pPre;
119     }
120     return NULL;
121 }
122 
123 //在指定数据之前插入数据
124 void insertdata(List *p, int data, int newdata)
125 {
126     node *pnew = (node *)malloc(sizeof(node));
127     pnew->data = newdata;
128     pnew->pNext = NULL;
129     pnew->pPre = NULL;
130 
131     //p1记录找到的位置
132     node *p1 = NULL;
133     p1 = p->head;
134     while (p1 != NULL)
135     {
136         if (p1->data != data)
137         {
138             p1 = p1->pNext;
139         }
140         else
141         {
142             break;
143         }
144     }
145     //中间情况
146     if (p1 != p->head && p1 != p->tail)
147     {
148         pnew->pNext = p1;
149         pnew->pPre = p1->pPre;
150 
151         p1->pPre->pNext = pnew;
152         p1->pNext->pPre = pnew;
153     }
154     else if (p1 == p->head)
155     {
156         pnew->pNext = p1;
157         p1->pPre = pnew;
158         p->head = pnew;
159 
160     }
161     else if (p1 == p->tail)
162     {
163         pnew->pNext = p1;
164         pnew->pPre = p1->pPre;
165 
166         p1->pPre->pNext = pnew;
167         p1->pPre = pnew;
168     }
169 }
170 
171 //删除指定数据
172 void deletedata(List *p, int data)
173 {
174     //p1遍历循环查找位置
175     node *p1 = NULL;
176     p1 = p->head;
177     while (p1 != NULL)
178     {
179         if (p1->data == data)
180         {
181             p1 = p1->pNext ;
182         }
183         else
184         {
185             break;
186         }
187     }
188     //p1记录找到的位置
189     //中间情况
190     if (p1 != p->head && p1 != p->tail)
191     {
192         p1->pPre->pNext = p1->pNext;
193         p1->pNext->pPre = p1->pPre;
194         free(p1);
195     }
196     else if (p1 == p->head)
197     {
198         p->head = p1->pNext;
199         p1->pNext->pPre = NULL;
200         free(p1);
201     }
202     else if (p1 == p->tail)
203     {
204         p->tail = p1->pPre;
205         p1->pPre->pNext = NULL;
206         free(p1);
207     }
208 }
209 
210 void main()
211 {
212     List dList;
213     init(&dList);
214     addDataHead(&dList,1);
215     addDataHead(&dList, 2);
216     addDataHead(&dList, 3);
217     addDataHead(&dList, 4);
218     addDataHead(&dList, 5);
219     //addDataBack(&dList, 10);
220     insertdata(&dList, 4, 939);
221     show(&dList);
222     /*revshow(&dList);
223     node *pfind = find(&dList, 3);
224     pfind->data = 12;
225     show(&dList);*/
226     /*deletedata(&dList, 3);
227     show(&dList);*/
228     system("pause");
229 }
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xiaochi/p/8401061.html