双向循环链表

  1 #include <stdio.h>
  2 typedef int DATATYPE;//定义int的别名，以防止以后结点内容不是int了可以方便替换
  3 //定义链表结点结构体
  4 struct node
  5 {
  6     DATATYPE data;//数据域
  7     struct node *left;//指向前一个结点,用left其实更便于理解
  8     struct node *right;//指向后一个结点用right也是为了便于理解，next也不错
  9 };
 10 typedef struct node Node;//定义别名，方便书写
 11  
 12 Node * createDList();//创建双向循环链表
 13 int insertList1(Node *head, DATATYPE data);//头插法插入
 14 int insertList2(Node *head, DATATYPE data);//尾插法插入
 15 void printDlist(Node * head);//打印链表内容
 16 Node *searchNode(Node *head, DATATYPE find);//查找链表中的元素，双向查找
 17 void sortList1(Node *head, int len);//交换内容排序 基于冒泡
 18 void sortList2(Node *head, int len);//交换指针排序 基于冒泡
 19 void sortList3(Node *head, int len);//基于选择排序的交换内容排序
 20 int deleteNode(Node *head, DATATYPE data);//删除指定节点
 21 int lenList(Node *head);//求双向循环链表的长度
 22 void destroyList(Node *head);//求双向循环链表的长度
 23  
 24 int main(void)
 25 {
 26     Node *head = createDList();//创建链表
 27     printf("head=%p\n", head);
 28     int i = 0;
 29     for (i = 7; i >= 0; i--)//为链表赋初始测试值
 30 //      insertList1(head, i);
 31         insertList2(head, i);
 32     printDlist(head);
 33     printf("——————\n");
 34     DATATYPE find = 3;//测试查找函数
 35     Node *search=searchNode(head, find);
 36     if (search != NULL)
 37         printf("search=%d\n", search->data);
 38     else
 39         printf("no such number\n");
 40     DATATYPE data = 0;
 41     deleteNode(head, data);//测试删除函数
 42     int len = lenList(head);//测试求长度函数
 43     printf("len=%d\n",len);
 44 //  sortList1(head, len);//测试排序函数
 45 //  sortList2(head, len);
 46     sortList3(head, len);
 47     printDlist(head);
 48     destroyList(head);//销毁所有结点
 49     printf("销毁后的头节点：=%p\n",head->right);
 50     printf("sizeof(head)=%d\n",sizeof(head));
 51     return 0;
 52 }
 53 //创建双向循环链表，只需要返回一个头结点就好
 54 //双向循环链表，就想一个闭环一样的概念，一般头结点中不存储内容
 55 Node * createDList()
 56 {
 57     Node *head = (Node *)malloc(sizeof(Node));
 58     if (head)
 59     {
 60         head->left = head;
 61         head->right = head;
 62         return head;
 63     }
 64     else
 65         return NULL;
 66 }
 67 //头插法插入，每次插入在头结点后紧跟着
 68 int insertList1(Node *head, DATATYPE data)
 69 {
 70     Node *newNode = (Node *)malloc(sizeof(Node));
 71     if (newNode)
 72     {
 73         newNode->data = data;
 74  
 75         newNode->left = head;
 76         newNode->right = head->right;
 77  
 78         head->right = newNode;
 79         newNode->right->left = newNode;
 80  
 81         return 1;
 82     }
 83     else
 84         return -1;
 85 }
 86 //尾插法插入，每次插入在头结点之前
 87 int insertList2(Node *head, DATATYPE data)
 88 {
 89     Node *newNode = (Node *)malloc(sizeof(Node));
 90     if (newNode)
 91     {
 92         newNode->data = data;
 93         head->left->right = newNode;
 94         newNode->left = head->left;
 95         newNode->right = head;
 96         head->left = newNode;
 97         return 1;
 98     }
 99     return -1;
100 }
101 //打印链表内容
102 void printDlist(Node * head)
103 {
104     Node *p = head->right;
105     while (p != head)
106     {
107         printf("%d\n", p->data);
108         p = p->right;
109     }
110 }
111 //查找链表中的元素，双向查找
112 Node *searchNode(Node *head, DATATYPE find)
113 {
114     Node *left = head;//left表示一个结点的前驱结点，初始值是头结点
115     Node *right = head;//right表示一个结点的后继结点，初始值是头结点
116     do
117     {
118         left = left->left;//移动向前一个
119         right = right->right;//移动向后一个
120         if (left->data == find)//如果此时结点发现查找内容，就返回结点信息
121             return left;
122         if (right->data == find)//如果此时结点发现查找内容，就返回结点信息
123             return right;  
124     } while (left != right && left->left!=right);//当两个结点相遇或者错过时候终止循环
125     //如果除了头结点是偶数个，则相互错过时候终止
126     //如果除了头结点是奇数个，则相遇时候终止查找
127     return NULL;   
128 }
129 //交换内容排序 基于冒泡
130 void sortList1(Node *head, int len)
131 {
132     int i = 0, j = 0;
133     Node *p, *q;
134     for (i = 0; i < len - 1; i++)
135     {
136         p = head->right;
137         q = p->right;
138         for (j = 0; j < len - 1 - i; j++)
139         {
140             if (p->data<q->data){
141                 p->data ^= q->data;
142                 q->data ^= p->data;
143                 p->data ^= q->data;
144             }
145             p = p->right;
146             q = q->right;
147         }
148     }
149      
150 }
151 //交换指针排序 基于冒泡
152 void sortList2(Node *head, int len)
153 {
154     Node *p, *q;
155     int i = 0, j = 0;
156     for (i = 0; i < len - 1; i++)
157     {
158         p = head->right;
159         q = p->right;
160         for (j = 0; j < len - 1-i; j++)
161         {
162             if (p->data < q->data){
163                 q->left = p->left;
164                 p->left->right = q;
165                 p->right = q->right;
166                 q->right->left = p;
167                 q->right = p;
168                 p->left = q;
169  
170                 q = p->right;
171                  
172             }
173             else{
174                 p = p->right;
175                 q = q->right;
176             }
177              
178         }
179     }
180 }
181 //基于选择排序的交换内容排序
182 void sortList3(Node *head, int len)
183 {
184     Node *p, *q, *max, *temp;
185     DATATYPE t;
186     p = head->right;
187     q = p->right;
188     int i = 0, j = 0;
189     for (i = 0; i < len-1 ; i++)
190     {
191         if (p == head)
192             break;
193         max = p;
194         q = p;
195         for (j = i; j < len; j++)
196         {
197             if (q == head)
198                 break;
199             if (max->data > q->data)
200                 max = q;
201             q = q->right;
202         }
203         if (max != p)
204         {
205             t = max->data;
206             max->data = p->data;
207             p->data = t;       
208         }
209         p = p->right;
210     }   
211 }
212 //基于选择排序的交换指针排序，写了但是一直出问题？
213 //删除指定节点
214 int deleteNode(Node *head, DATATYPE data)
215 {
216     Node *search = searchNode(head, data);
217     if (search){
218         search->left->right = search->right;
219         search->right->left = search->left;
220         free(search);
221         return 1;
222     }
223     return 0;
224 }
225 //求双向循环链表的长度
226 int lenList(Node *head)
227 {
228     Node *p = head;
229     int len = 0;
230     while (p->right != head){
231         len++;
232         p = p->right;
233     }
234     return len;
235 }
236 //销毁所有记录
237 void destroyList(Node *head)
238 {
239     Node *p = head->right;
240     while (p != head)
241     {
242         p = p->right;
243         free(p->left);
244     }
245     free(head);
246      
247 }