含有头结点双向循环链表

最新推荐文章于 2019-09-16 17:38:06 发布
原创最新推荐文章于 2019-09-16 17:38:06 发布 · 465 阅读
CC 4.0 BY-SA版权
 1 #include <stdio.h>         /*含有头结点双向循环链表*/
  2 #include <stdlib.h>
  3 
  4 #define T 1
  5 #define F 2
  6 
  7 typedef int ElementType;
  8 typedef int Boolean;
  9 
 10 struct Node
 11 {
 12     struct Node* prior;
 13     ElementType value;
 14     struct Node* next;
 15 };
 16 
 17 typedef struct Node* node;
 18 
 19 Boolean insert_tail(node head, ElementType value);   /*尾插*/
 20 Boolean insert_head(node head, ElementType value);   /*头插*/
 21 Boolean insert_index(node head, ElementType value, int index);  /*指定位置插入新值*/
 22 Boolean delete_index(node head, int index);             /*指定位置删除*/
 23 Boolean delete_value(node head, ElementType value);     /*指定数据删除*/
 24 Boolean update_index(node head, ElementType value, int index);   /*指定位置修改数据*/
 25 Boolean update_value(node head, ElementType old_value, ElementType new_value);  /*将数据修改*/
 26 Boolean quary_index(node head, int index);   /*指定位置察值*/
 27 Boolean quary_value(node head, ElementType value);  /*指定数据的位置*/
 28 
 29 Boolean init(node* head);       /*初始化*/
 30 int length(node head);    /*除去头结点的总长度*/
 31 void printP(node head);   /*前驱打印*/
 32 void printN(node head);   /*后驱打印*/
 33 
 34 int main()
 35 {
 36     int i;
 37     node head = NULL;
 38 
 39     init(&head);
 40     for (i = 0; i < 10; i++)
 41     {
 42         insert_head(head, i);
 43     }
 44     printN(head);
 45     printP(head);
 46 
 47     for (i = 0; i < 10; i++)
 48     {
 49         insert_tail(head, i);
 50     }
 51     printN(head);
 52     printP(head);
 53     printf("length = %d\n", length(head));
 54 
 55     insert_index(head, 99, 0);
 56     insert_index(head, 99, 11);
 57     insert_index(head, 99, length(head));
 58     printN(head);
 59     printP(head);
 60 
 61     delete_index(head, 0);
 62     delete_index(head, 10);
 63     delete_index(head, length(head)-1);
 64     printN(head);
 65     printP(head);
 66 
 67     delete_value(head, 0);
 68     printN(head);
 69     printP(head);
 70 
 71     update_index(head, 88 , 1);
 72     update_index(head, 88 , length(head)-2);
 73     printN(head);
 74 
 75     update_value(head, 88 , 888);
 76     printN(head);
 77 
 78     quary_index(head, 1);
 79     quary_index(head, length(head)-2);
 80 
 81     quary_value(head, 88);
 82     quary_value(head, 888);
 83 
 84     return 0;
 85 }
 86 
 87 Boolean quary_index(node head, int index)
 88 {
 89     if (index < 0 || index > length(head))
 90     {
 91         return F;
 92     }
 93     int i;
 94     for (i = 0; i < index; i++)
 95     {
 96         head = head->next;
 97     }
 98     printf("find = %d index =%d\n", head->next->value, index);
 99 
100     return T;
101 }
102 
103 Boolean quary_value(node head, ElementType value)
104 {
105     node temp = head;
106     int i = 0;
107     int count = 0;
108     while (temp->next != head)
109     {
110         if (temp->next->value == value)
111         {
112             i++;
113             printf("find = %d index = %d\n", value, count );
114         }
115         count++;
116         temp = temp->next;
117     }
118     if (0 == i)
119     {
120         printf("no this value\n");
121     }
122     return T;
123 }
124 
125 Boolean update_index(node head, ElementType value, int index)
126 {
127     if (index < 0 || index > length(head))
128     {
129         return F;
130     }
131     int i;
132     for (i = 0; i < index; i++)
133     {
134         head = head->next;
135     }
136     head->next->value = value;
137 
138     return T;
139 }
140 
141 Boolean update_value(node head, ElementType old_value, ElementType new_value)
142 {
143     node temp = head;
144     while (temp->next != head)
145     {
146         if (temp->next->value == old_value)
147         {
148             temp->next->value = new_value;
149         }
150             temp = temp->next;
151     }
152     return T;
153 }
154 Boolean delete_index(node head, int index)
155 {
156     if (index < 0 || index > length(head))
157     {
158         return F;
159     }
160     int i;
161     for (i = 0; i < index; i++)
162     {
163         head = head->next;
164     }
165 
166     node temp = head->next->next;
167     free(head->next);
168     head->next = temp;
169     temp->prior = head;
170 
171     return 0;
172 
173 }
174 
175 Boolean delete_value(node head, ElementType value)
176 {
177    node temp = head;
178    while (temp->next != head)
179    {
180        if (temp->next->value == value)
181        {
182            node temp2 = temp->next->next;
183            free(temp->next);
184            temp->next = temp2;
185            temp2->prior = temp;
186        }
187        else
188        {
189            temp = temp->next;
190        }
191    }
192     return T;
193 }
194 
195 Boolean insert_index(node head, ElementType value, int index)
196 {
197     node temp = head;
198     node newnode = (node)malloc(sizeof(struct Node));
199     if (NULL == newnode)
200     {
201         return F;
202     }
203     if (index < 0 || index > length(head))
204     {
205         return F;
206     }
207     newnode->value = value;
208     int i;
209     for (i = 0; i < index; i++)
210     {
211         temp = temp->next;
212     }
213     newnode->next = temp->next;
214     temp->next = newnode;
215     newnode->next->prior = newnode;
216     newnode->prior = temp;
217 
218     return T;
219 
220 }
221 
222 Boolean insert_head(node head, ElementType value)
223 {
224     node newnode = (node)malloc(sizeof(struct Node));
225     if (NULL == newnode)
226     {
227         return F;
228     }
229     newnode->value = value;
230 
231     newnode->next = head->next;
232     head->next = newnode;
233     newnode->next->prior = newnode;
234     newnode->prior = head;
235 
236     return T;
237 }
238 
239 Boolean insert_tail(node head, ElementType value)
240 {
241     node newnode = (node)malloc(sizeof(struct Node));
242     if (NULL == newnode)
243     {
244         return F;
245     }
246     newnode->value = value;
247 
248     head->prior->next = newnode;
249     newnode->next = head;
250     newnode->prior = head->prior;
251     head->prior = newnode;
252 
253     return T;
254 }
255 int length(node head)
256 {
257     int count = 0;
258     node temp = head;
259     while (temp->next != head)
260     {
261         count++;
262         temp = temp->next;
263     }
264     return count;
265 }
266 
267 Boolean init(node* head)
268 {
269     node newnode = (node)malloc(sizeof(struct Node));
270     if (NULL == newnode)
271     {
272         return F;
273     }
274     newnode->next = newnode;
275     newnode->prior = newnode;
276 
277     *head = newnode;
278 
279      return T;
280 }
281 
282 void printP(node head)
283 {
284     node temp = head;
285     while (temp->prior != head)               /*temp->prior->prior */
286     {
287         printf("%d ", temp->prior->value);
288         temp = temp->prior;
289     }
290     printf("\n");
291 
292 }
293 void printN(node head)
294 {
295     node temp = head;
296     while (temp->next != head)  /*temp->next->next */
297     {
298         printf("%d ", temp->next->value);
299         temp = temp->next;
300     }
301     printf("\n");
302 
303 }