循环双链表的简单操作

下面是循环双链表的简单操作，其中很多细节没有考虑到，比如没有判断空链表，目的提供思想，如有出现错误，请大家指正！

点击(此处)折叠或打开

1. #include<iostream>
   
2. //#include<stdlib.h>
   
3. using namespace std;
   
4. struct List {
   
5. 
   
6.     int data;
   
7.     struct List *last, *next;
   
8. };
   
9. 
   
10. List *CreateList() {
    
11. 
    
12.     List *first;
    
13.     first = new List; //first = (List *)malloc(sizeof(List));
    
14.     first->next = first;
    
15.     first->last = first;
    
16.     return first;
    
17. }
    
18. 
    
19. List *InitialList(List *first) {
    
20. 
    
21.     List *p, *head;
    
22.     head = first;
    
23.     for (int i = 0; i < 5; i++) {
    
24. 
    
25.         p = new List;
    
26.         p->data = i;
    
27.         p->last = head;
    
28.      head->next = p;
    
29.         
    
30.         head = p;
    
31.     }
    
32. 
    
33.     first->last = head;
    
34.     head->next = first;
    
35.     return first;
    
36. }
    
37. 
    
38.     void PrintList(List *first){
    
39.         List *q = first;
    
40.         first = first->next;
    
41.         cout << "正序打印：";
    
42.         for (; first != q; first = first->next) {
    
43. 
    
44.             cout << first->data << " ";
    
45.         }
    
46.         
    
47.         cout << endl;
    
48. 
    
49.         List *p = first;
    
50.         first = first->last;
    
51.         cout << "逆序打印：";
    
52.         for (; first != p; first = first->last) {
    
53. 
    
54.             cout << first->data << " ";
    
55.         }
    
56.     }
    
57. 
    
58.     void InsertList(List *first,int i,int x) {
    
59. 
    
60.         List *head, *p;
    
61.         head = first;
    
62. 
    
63.         for (int j = 0; j < i - 1; j++) {
    
64. 
    
65.             head = head->next;
    
66.         }
    
67.         
    
68.         p = new List;
    
69.         p->data = x;
    
70.         p->last = head;
    
71.         p->next = head->next; //P
    
72.         head->next->last = p;  
    
73.         head->next = p;  //该过程操作有顺序，该步一定要在P之后，否则会覆盖head ->next
    
74. 
    
75.     }
    
76. 
    
77.     void DeleteList(List *first, int i) {
    
78. 
    
79.         List *head, *p;
    
80.         head = first;
    
81. 
    
82.         for (int j = 0; j < i; j++) {
    
83. 
    
84.             head = head->next;
    
85.         }
    
86. 
    
87.         p = head;
    
88.         head->last->next = head->next;   //由于是循环双链表，可以直接以删除点为中心操作
    
89.         head->next->last = head->last;
    
90.         delete p;
    
91.         p = NULL;
    
92. 
    
93.         first = first->next;
    
94. 
    
95.         for (; !first; first = first->next) {
    
96. 
    
97.             cout << first->data << " ";
    
98.         }
    
99. 
    
100.     }
     
101.         void DestoryList(List *first){
     
102. 
     
103.             List *p, *head;
     
104.             head = first;
     
105.             while(head !=first){
     
106. 
     
107.                 p = head;
     
108.                 head = head ->next;
     
109.                 delete p;
     
110.                 
     
111.             }
     
112.             delete first; //一定要销毁头指针
     
113.             first = NULL; //为了防止出现迷途指针，将头结点置空
     
114.             cout << "链表已经销毁" << endl;
     
115.             exit(0);
     
116.         }
     
117.     
     
118.     int main() {
     
119. 
     
120.         List *s,*t;
     
121.         s = CreateList();
     
122.         t = InitialList(s);
     
123.         DestoryList(t);
     
124.         //InsertList(t, 3, 11);
     
125.         //DeleteList(t,4);
     
126.         PrintList(t);
     
127.     }

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29876893/viewspace-1814415/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/29876893/viewspace-1814415/