静态链表，初始化、输入、打印、删除、插入

奥普瓯江

代码：

1. #include <stdio.h>
   
2. #define MAXSIZE 1000
   
3. 
   
4. typedef struct
   
5. {
   
6.         char date;
   
7.         int cur;
   
8. }nice;
   
9. 
   
10. nice * InitList(nice space[]);        //初始化数组
    
11. nice * getList(nice space[]);        //输入数据
    
12. void PrinList(nice space[]);        //打印数组
    
13. nice * deleList(nice space[]);        //删除特定的数据
    
14. nice * insertList(nice space[]);        //插入数据
    
15. 
    
16. nice * insertList(nice space[])
    
17. {
    
18.         char T;
    
19.         int i = 0, temp, ctemp;
    
20.         T = getchar();
    
21.         getchar();
    
22. 
    
23.         while (1)
    
24.         {
    
25.                 if (i == 0)
    
26.                 {
    
27.                         i = space[MAXSIZE - 1].cur;
    
28.                 }
    
29.                 else
    
30.                 {
    
31.                         i = space[i].cur;
    
32.                 }
    
33.                 if (space[i].date == T)
    
34.                 {
    
35.                         temp = space[space[0].cur].cur;        //把0数组的下一位数组单独提取出来
    
36.                         space[temp].date = getchar();
    
37.                         getchar();
    
38. 
    
39.                         /*if (space[MAXSIZE - 1].cur == i)        //前插
    
40.                         {
    
41.                                 space[space[0].cur].cur = space[temp].cur;        //把最后两个链表连接起来
    
42.                                 space[temp].cur = space[MAXSIZE - 1].cur;        //把第一个链表的下标给与temp下标的cur
    
43.                                 space[MAXSIZE - 1].cur = temp;                                //把第一个链表数组更改为temp(最后一个数组中的cur是记录谁是第一个带数据数组的)
    
44.                         }
    
45.                         else
    
46.                         {
    
47.                                 space[space[0].cur].cur = space[temp].cur;        //把最后两个链表连接起来
    
48.                                 space[temp].cur = i;                                                //把单独腾挪出来的数组数值储存段赋予本次数组数值
    
49.                                 space[ctemp].cur = temp;                                        //把单独腾挪出来的数组的下标赋值给上一个数组的cur位置
    
50.                                        
    
51.                         }*/
    
52. 
    
53.                         //后插
    
54.                         space[space[0].cur].cur = space[temp].cur;
    
55.                         space[temp].cur = space[i].cur;
    
56.                         space[i].cur = temp;
    
57. 
    
58. 
    
59. 
    
60.                         break;
    
61.                 }
    
62.                 ctemp = i;                //用于前插得变量
    
63.         }
    
64. 
    
65. 
    
66.         return space;
    
67. }
    
68. 
    
69. nice * deleList(nice space[])
    
70. {
    
71.         char T;
    
72.         int i = 0, temp;
    
73. 
    
74.         T = getchar();
    
75.         getchar();
    
76. 
    
77.         while (1)
    
78.         {
    
79.                
    
80.                 if (i == 0)
    
81.                 {
    
82.                         i = space[MAXSIZE - 1].cur;
    
83.                 }
    
84.                 else
    
85.                 {
    
86.                         i = space[i].cur;
    
87.                 }
    
88.                 if (space[i].date == T)
    
89.                 {
    
90.                         if (space[MAXSIZE - 1].cur == i)
    
91.                         {
    
92.                                 space[MAXSIZE - 1].cur = space[i].cur;
    
93.                                 space[i].cur = space[space[0].cur].cur;
    
94.                                 space[space[0].cur].cur = i;
    
95.                                
    
96.                         }
    
97.                         else
    
98.                         {
    
99.                                 space[temp].cur = space[i].cur;
    
100.                                 space[i].cur = space[space[0].cur].cur;
     
101.                                 space[space[0].cur].cur = i;       
     
102.                         }
     
103.                        
     
104.                         break;
     
105.                 }
     
106.                 temp = i;
     
107.         }
     
108. 
     
109.         return space;
     
110. }
     
111. 
     
112. nice * getList(nice space[])
     
113. {
     
114. 
     
115.         if (space[MAXSIZE - 1].cur == MAXSIZE)
     
116.         {                               
     
117.                 space[MAXSIZE - 1].cur = 1;
     
118.         }
     
119. 
     
120.         space[space[0].cur].date = getchar();
     
121.         getchar();
     
122.         space[0].cur = space[space[0].cur].cur;
     
123.         return space;
     
124. }
     
125. 
     
126. void PrinList(nice space[])
     
127. {
     
128.         int i = 0;
     
129. 
     
130.         while (1)
     
131.         {
     
132.                
     
133.                 if (i == 0)
     
134.                 {
     
135.                         i = space[MAXSIZE - 1].cur;
     
136.                 }
     
137.                 else
     
138.                 {
     
139.                         i = space[i].cur;
     
140.                 }
     
141. 
     
142.                 if (space[0].cur == i)
     
143.                 {
     
144.                         break;
     
145.                 }
     
146.                 printf("<%d:%c>",space[i].cur, space[i].date);
     
147. 
     
148.                
     
149.         }
     
150. }
     
151. 
     
152. nice * InitList(nice space[])
     
153. {
     
154.         int i = 0;
     
155. 
     
156.         for (i = 0; i <= MAXSIZE -1; i++)
     
157.         {
     
158.                 space[i].cur = i + 1;
     
159.         }
     
160. 
     
161.         return space;
     
162. }
     
163. 
     
164. 
     
165. int main()
     
166. {
     
167.         int T;
     
168.         nice space[MAXSIZE];
     
169.         while (1)
     
170.         {
     
171.                 printf("输入选项：");
     
172.                 scanf("%d", &T);
     
173.                 getchar();
     
174.                
     
175.                 switch(T)
     
176.                 {
     
177.                 case 1:{
     
178.                         InitList(space);        //初始化数组
     
179.                         break;
     
180.                            }
     
181.                 case 2:{
     
182.                         getList(space);                //输入数据
     
183.                         break;
     
184.                            }
     
185.                 case 3:{
     
186.                         deleList(space);        //删除数据
     
187.                         break;
     
188.                            }
     
189.                 case 4:{
     
190.                         insertList(space);        //插入数据
     
191.                         break;
     
192.                            }
     
193.                 case 9:{
     
194.                         PrinList(space);        //打印数组
     
195.                         putchar('\n');
     
196.                         break;
     
197.                            }
     
198.                 case 0:{
     
199.                         return 0;
     
200.                            }
     
201.                 }
     
202.         }
     
203.        
     
204.         return 0;
     
205. }

复制代码