初始化链表、头插链表、尾插链表、两个链表相连

奥普瓯江

相连后我就不释放N链表的头节点了我这从新建立了一个K链表返回之后付给新新链表

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <time.h>
   
4. 
   
5. #define MAXSIZE 10
   
6. 
   
7. typedef struct Like
   
8. {
   
9.     int T;
   
10.     struct Like *next;
    
11. }Like, *Likes;
    
12. 
    
13. 
    
14. void Explain();     //程序说明
    
15. void InitList(Likes *N);    //初始化及清除数据
    
16. void TailList(Likes *M);     //创建尾插法链表
    
17. void HeadList(Likes *N);     //创建尾插法链表
    
18. void AlPuList(Like *N);     //打印链表
    
19. struct Like *LinkList(Like *N, Like *M); //两个链表合并
    
20. 
    
21. struct Like *LinkList(Like *N, Like *M)
    
22. {
    
23.     Like *temp = N->next->next;     //N的一号节点传给临时变量
    
24.     N->next->next = M->next->next;  //M的1号节点传给N尾节点之后
    
25.     M->next->next = temp;           //N1号节点传给M节点之后也就是当M的一号数据
    
26. 
    
27.     return M->next;
    
28. }
    
29. 
    
30. void AlPuList(Like *N)
    
31. {
    
32.     Like *temp = N->next;
    
33. 
    
34.     do
    
35.     {
    
36.         printf("<%d>", temp->T);
    
37.         temp = temp->next;
    
38. 
    
39.     }while(temp != N->next);
    
40.     putchar('\n');
    
41. 
    
42. }
    
43. 
    
44. void TailList(Likes *M)
    
45. {
    
46.     Like *temp, *tail;
    
47.     srand((unsigned)time(NULL));        //随意创建N个链表
    
48. 
    
49.     for(int i = 0; i < MAXSIZE; i++)
    
50.     {
    
51.         temp = (Likes )malloc(sizeof(Like ));
    
52.         temp->T = (rand() % 100);
    
53.         temp->next = (*M)->next;
    
54. 
    
55.         if((*M)->next == *M)
    
56.         {
    
57.             (*M)->next = temp;
    
58.         }
    
59.         else
    
60.         {
    
61.             tail->next = temp;
    
62.         }
    
63.         tail = temp;
    
64.     }
    
65.     (*M)->next = tail;
    
66. 
    
67. }
    
68. void HeadList(Likes *N)
    
69. {
    
70.     Like *temp, *tail;
    
71.     srand((unsigned)time(NULL));
    
72. 
    
73.     for(int i = 0; i < MAXSIZE; i++)
    
74.     {
    
75.         temp = (Likes )malloc(sizeof(Like ));
    
76.         temp->T = (rand() % 100);
    
77. 
    
78.         if((*N)->next == *N )
    
79.         {
    
80.             (*N)->next = temp;
    
81.             temp->next = temp;  //自己指向自己
    
82.             tail = temp;        //把尾链表传给tail，（tail不做更改）
    
83.         }
    
84.         else
    
85.         {
    
86.             temp->next = (*N)->next;    //把链表1号节点传给临时链表temp->next
    
87.             (*N)->next = temp;          //把temp替换1号节点的数据因为前面已经做了向下一个的next所以链表是相连的
    
88.             tail->next = temp;          //把尾节点的指向next替换成新的1号节点点形成循环
    
89.         }
    
90.     }
    
91.     (*N)->next = tail;                  //把链表的头节点指向链表的尾节点
    
92. 
    
93. }
    
94. 
    
95. void InitList(Likes *N)
    
96. {
    
97.     Like *temp,*temps;
    
98. 
    
99.   if(*N != NULL)
    
100.     {
     
101.         temp = (*N)->next;
     
102.         do
     
103.         {
     
104.             temps = temp;
     
105.             temp = temp->next;
     
106.             free(temps);
     
107.         }while((*N)->next != temp);
     
108.     }
     
109.     else
     
110.     {
     
111.         *N = (Likes )malloc(sizeof(Like ));
     
112.     }
     
113.     (*N)->next = *N;
     
114. 
     
115. 
     
116. 
     
117. 
     
118. }
     
119. void Explain()
     
120. {
     
121.     printf("1、初始化程序及清除数据\n");
     
122.     printf("2、创建头插法链表\n");
     
123.     printf("3、创建尾插法链表\n");
     
124.     printf("4、两个链表合并\n");
     
125.     printf("9、打印全部链表\n");
     
126.     printf("0、结束本程序\n");
     
127. }
     
128. 
     
129. int main()
     
130. {
     
131.     int i;
     
132.     Like *N = NULL, *M = NULL, *K;
     
133. 
     
134.     Explain();
     
135. 
     
136.     while(1)
     
137.     {
     
138.         printf("输入选项：");
     
139.         scanf("%d",&i);
     
140. 
     
141.         switch(i)
     
142.         {
     
143.             case 1:{
     
144.                 InitList(&N);
     
145.                 InitList(&M);
     
146.             }
     
147.             break;
     
148.             case 2:{
     
149.                 HeadList(&N);
     
150.             }
     
151.             break;
     
152.             case 3:{
     
153.                 TailList(&M);
     
154.             }
     
155.             break;
     
156.             case 4:{
     
157.                 K = LinkList(N, M);
     
158.                 AlPuList(K);
     
159.             }
     
160.             break;
     
161.              case 9:{
     
162.                AlPuList(N);
     
163.                AlPuList(M);
     
164.             }
     
165.             break;
     
166.             case 0:{
     
167.                 return 0;
     
168.             }
     
169.             break;
     
170.         }
     
171. 
     
172.     }
     
173. 
     
174.     return 0;
     
175. }
     

复制代码