第四周项目五

*/

Copyright (c++) 2017,烟台大学计算机与控制工程学院

文件名称：linklist
作 者：贾存钰
完成日期：2017年10月7日
问题描述：设非空线性表ha和hb都用带头节点的循环双链表表示。
设计一个算法Insert(ha,hb,i)。其功能是：i=0时，将线性表hb插入到线性表ha的最前面；
当i>0时，将线性表hb插入到线性表ha中第i个节点的后面；当i大于等于线性表ha的长度时，
将线性表hb插入到线性表ha的最后面。
输入描述:无
输出描述：ha和hb以及新的线性表

[cpp]  view plain  copy

1. #ifndef CDLINKLIST_H_INCLUDED  
2. #define CDLINKLIST_H_INCLUDED  
3.   
4. //循环双链表基本运算函数  
5. typedef int ElemType;  
6. typedef struct DNode        //定义双链表结点类型  
7. {  
8.     ElemType data;  
9.     struct DNode *prior;    //指向前驱结点  
10.     struct DNode *next;     //指向后继结点  
11. } CDLinkList;  
12.   
13. void CreateListF(CDLinkList *&L,ElemType a[],int n); //头插法建立循环双链表  
14. void CreateListR(CDLinkList *&L,ElemType a[],int n); //尾插法建立循环双链表  
15. void InitList(CDLinkList *&L); //初始化循环双链表  
16. void DestroyList(CDLinkList *&L);  //销毁  
17. bool ListEmpty(CDLinkList *L); //判断是否为空  
18. int ListLength(CDLinkList *L); //求链表长度  
19. void DispList(CDLinkList *L);  //输出链表  
20. bool GetElem(CDLinkList *L,int i,ElemType &e);  //取链表元素  
21. int LocateElem(CDLinkList *L,ElemType e);  //查找元素  
22. bool ListInsert(CDLinkList *&L,int i,ElemType e);  //插入节点  
23. bool ListDelete(CDLinkList *&L,int i,ElemType &e);  //删除节点  
24.   
25. #endif // CDLINKLIST_H_INCLUDED  

[cpp]  view plain  copy

1. //循环双链表基本运算函数  
2. #include <stdio.h>  
3. #include <malloc.h>  
4. #include "linklist.h"  
5. void CreateListF(CDLinkList *&L,ElemType a[],int n) //头插法建立循环双链表  
6. {  
7.     CDLinkList *s;  
8.     int i;  
9.     L=(CDLinkList *)malloc(sizeof(CDLinkList));     //创建头结点  
10.     L->next=NULL;  
11.     for (i=0; i<n; i++)  
12.     {  
13.         s=(CDLinkList *)malloc(sizeof(CDLinkList));//创建新结点  
14.         s->data=a[i];  
15.         s->next=L->next;            //将*s插在原开始结点之前,头结点之后  
16.         if (L->next!=NULL) L->next->prior=s;  
17.         L->next=s;  
18.         s->prior=L;  
19.     }  
20.     s=L->next;  
21.     while (s->next!=NULL)           //查找尾结点,由s指向它  
22.         s=s->next;  
23.     s->next=L;                      //尾结点next域指向头结点  
24.     L->prior=s;                     //头结点的prior域指向尾结点  
25.   
26. }  
27. void CreateListR(CDLinkList *&L,ElemType a[],int n) //尾插法建立循环双链表  
28. {  
29.     CDLinkList *s,*r;  
30.     int i;  
31.     L=(CDLinkList *)malloc(sizeof(CDLinkList));  //创建头结点  
32.     L->next=NULL;  
33.     r=L;                    //r始终指向尾结点,开始时指向头结点  
34.     for (i=0; i<n; i++)  
35.     {  
36.         s=(CDLinkList *)malloc(sizeof(CDLinkList));//创建新结点  
37.         s->data=a[i];  
38.         r->next=s;  
39.         s->prior=r; //将*s插入*r之后  
40.         r=s;  
41.     }  
42.     r->next=L;              //尾结点next域指向头结点  
43.     L->prior=r;             //头结点的prior域指向尾结点  
44. }  
45. void InitList(CDLinkList *&L) //初始化循环双链表  
46. {  
47.     L=(CDLinkList *)malloc(sizeof(CDLinkList));     //创建头结点  
48.     L->prior=L->next=L;  
49. }  
50. void DestroyList(CDLinkList *&L)  //销毁  
51. {  
52.     CDLinkList *p=L,*q=p->next;  
53.     while (q!=L)  
54.     {  
55.         free(p);  
56.         p=q;  
57.         q=p->next;  
58.     }  
59.     free(p);  
60. }  
61. bool ListEmpty(CDLinkList *L) //判断是否为空  
62. {  
63.     return(L->next==L);  
64. }  
65. int ListLength(CDLinkList *L) //求链表长度  
66. {  
67.     CDLinkList *p=L;  
68.     int i=0;  
69.     while (p->next!=L)  
70.     {  
71.         i++;  
72.         p=p->next;  
73.     }  
74.     return(i);  
75. }  
76. void DispList(CDLinkList *L)  //输出链表  
77. {  
78.     CDLinkList *p=L->next;  
79.     while (p!=L)  
80.     {  
81.         printf("%d ",p->data);  
82.         p=p->next;  
83.     }  
84.     printf("\n");  
85. }  
86. bool GetElem(CDLinkList *L,int i,ElemType &e)  //取链表元素  
87. {  
88.     int j=0;  
89.     CDLinkList *p;  
90.     if (L->next!=L)     //双链表不为空表时  
91.     {  
92.         if (i==1)  
93.         {  
94.             e=L->next->data;  
95.             return true;  
96.         }  
97.         else            //i不为1时  
98.         {  
99.             p=L->next;  
100.             while (j<i-1 && p!=L)  
101.             {  
102.                 j++;  
103.                 p=p->next;  
104.             }  
105.             if (p==L)  
106.                 return false;  
107.             else  
108.             {  
109.                 e=p->data;  
110.                 return true;  
111.             }  
112.         }  
113.     }  
114.     else                //双链表为空表时  
115.         return 0;  
116. }  
117. int LocateElem(CDLinkList *L,ElemType e)  //查找元素  
118. {  
119.     int n=1;  
120.     CDLinkList *p=L->next;  
121.     while (p!=NULL && p->data!=e)  
122.     {  
123.         n++;  
124.         p=p->next;  
125.     }  
126.     if (p==NULL)  
127.         return(0);  
128.     else  
129.         return(n);  
130. }  
131. bool ListInsert(CDLinkList *&L,int i,ElemType e)  //插入节点  
132. {  
133.     int j=0;  
134.     CDLinkList *p=L,*s;  
135.     if (p->next==L)                 //原双链表为空表时  
136.     {  
137.         s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s  
138.         s->data=e;  
139.         p->next=s;  
140.         s->next=p;  
141.         p->prior=s;  
142.         s->prior=p;  
143.         return true;  
144.     }  
145.     else if (i==1)                  //原双链表不为空表但i=1时  
146.     {  
147.         s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s  
148.         s->data=e;  
149.         s->next=p->next;  
150.         p->next=s;  //将*s插入到*p之后  
151.         s->next->prior=s;  
152.         s->prior=p;  
153.         return true;  
154.     }  
155.     else  
156.     {  
157.         p=L->next;  
158.         while (j<i-2 && p!=L)  
159.         {  
160.             j++;  
161.             p=p->next;  
162.         }  
163.         if (p==L)               //未找到第i-1个结点  
164.             return false;  
165.         else                    //找到第i-1个结点*p  
166.         {  
167.             s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s  
168.             s->data=e;  
169.             s->next=p->next;    //将*s插入到*p之后  
170.             if (p->next!=NULL) p->next->prior=s;  
171.             s->prior=p;  
172.             p->next=s;  
173.             return true;  
174.         }  
175.     }  
176. }  
177. bool ListDelete(CDLinkList *&L,int i,ElemType &e)  //删除节点  
178. {  
179.     int j=0;  
180.     CDLinkList *p=L,*q;  
181.     if (p->next!=L)                 //原双链表不为空表时  
182.     {  
183.         if (i==1)                   //i==1时  
184.         {  
185.             q=L->next;              //删除第1个结点  
186.             e=q->data;  
187.             L->next=q->next;  
188.             q->next->prior=L;  
189.             free(q);  
190.             return true;  
191.         }  
192.         else                        //i不为1时  
193.         {  
194.             p=L->next;  
195.             while (j<i-2 && p!=NULL)  
196.             {  
197.                 j++;  
198.                 p=p->next;  
199.             }  
200.             if (p==NULL)                //未找到第i-1个结点  
201.                 return false;  
202.             else                        //找到第i-1个结点*p  
203.             {  
204.                 q=p->next;              //q指向要删除的结点  
205.                 if (q==NULL) return 0;  //不存在第i个结点  
206.                 e=q->data;  
207.                 p->next=q->next;        //从单链表中删除*q结点  
208.                 if (p->next!=NULL) p->next->prior=p;  
209.                 free(q);                //释放*q结点  
210.                 return true;  
211.             }  
212.         }  
213.     }  
214.     else  
215.         return false;   //原双链表为空表时  
216. }  

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3. #include "linklist.h"  
4.   
5. void Insert(CDLinkList *&ha, CDLinkList *&hb,int i)  
6. {  
7.     CDLinkList *p=ha->next,*q;  
8.     int lena=1,j=1;  
9.     while (p->next!=ha) //求出ha的长度lena  
10.     {  
11.         lena++;  
12.         p=p->next;  
13.     }  
14.     if (i==0)   //将hb的所有数据结点插入到ha的头结点和第1个数据结点之间  
15.     {  
16.         p=hb->prior;        //p指向hb的最后一个结点/  
17.         p->next=ha->next;       //将*p链到ha的第1个数据结点前面  
18.         ha->next->prior=p;  
19.         ha->next=hb->next;  
20.         hb->next->prior=ha;     //将ha头结点与hb的第1个数据结点链起来  
21.     }  
22.     else if (i<lena)            //将hb插入到ha中间  
23.     {  
24.         p=ha->next;  
25.         while (j<i)         //在ha中查找第i个结点*p  
26.         {  
27.             j++;  
28.             p=p->next;  
29.         }  
30.         q=p->next;          //q指向*p结点的后继结点/  
31.         p->next=hb->next;       //hb->prior指向hb的最后一个结点  
32.         hb->next->prior=p;  
33.         hb->prior->next=q;  
34.         q->prior=hb->prior;  
35.     }  
36.     else                        //将hb链到ha之后  
37.     {  
38.         ha->prior->next=hb->next; //ha->prior指向ha的最后一个结点  
39.         hb->next->prior=ha->prior;  
40.         hb->prior->next=ha;  
41.         ha->prior=hb->prior;  
42.     }  
43.     free(hb);   //释放hb头结点  
44. }  
45.   
46. int main()  
47. {  
48.     CDLinkList *HA, *HB;  
49.     ElemType ha[]= {0, 1, 2, 3, 4, 5, 6, 7 ,8, 9};  
50.     InitList(HA);  
51.     CreateListF(HA, ha, 10);  
52.     ElemType hb[]= {100, 200, 300, 400, 500};  
53.     InitList(HB);  
54.     CreateListF(HB, hb, 5);  
55.     printf("HA: ");  
56.     DispList(HA);  
57.     printf("HB: ");  
58.     DispList(HB);  
59.     Insert(HA, HB, 0);  //将0改为其他值，多次运行程序完成测试  
60.     printf("new HA: ");  
61.     DispList(HA);  
62.     DestroyList(HA);  
63.     return 0;  
64. }