单链表的写的一个小程序,大家拿去测试下,有不足之处望指出.

Be_envious

1. #include<stdio.h>
   
2. #include<malloc.h>
   
3. 
   
4. struct node
   
5. {
   
6. int data; //数据域
   
7. struct node *next; //指针域
   
8. };
   
9. 
   
10. //函数声明
    
11. struct node * creat(void); //创建链表
    
12. void print(struct node *); //输出链表
    
13. void listinsert(struct node *); //插入元素
    
14. void listdelete(struct node *); //删除元素
    
15. 
    
16. //主函数
    
17. int main(void)
    
18. {
    
19. //在主函数里创建空的头指针
    
20. struct node * phead = NULL;
    
21. 
    
22. phead = creat(); //从头指针开始创建链表
    
23. printf("\n");
    
24. char quit;
    
25. do
    
26. {
    
27. char select;
    
28. printf("输入 p:打印 i:插入 d:删除\n");
    
29. select = getch();
    
30. switch(select)
    
31. {
    
32. case 'p' :
    
33. {
    
34. printf("\n当前可以接客的小妞有:\n");
    
35. print(phead);
    
36. printf("\n");
    
37. } break;
    
38. case 'i' :
    
39. {
    
40. char exit;
    
41. do
    
42. {
    
43. printf("在职的小妞:\n");
    
44. print(phead);
    
45. printf("你有多少小妞我全收了!\n");
    
46. listinsert(phead);
    
47. printf("\ne:退出\t任意键继续\n");
    
48. exit = getch();
    
49. }
    
50. while(exit != 'e');
    
51. printf("\n感谢您为我们带来新的小妞!\n");
    
52. } break;
    
53. case 'd' :
    
54. {
    
55. char exit;
    
56. do
    
57. {
    
58. printf("在职的小妞:");
    
59. print(phead);
    
60. printf("我们这里有很多小妞,你可以随意的挑选!\n");
    
61. listdelete(phead);
    
62. printf("\ne:退出\t任意键继续\n");
    
63. exit = getch();
    
64. }
    
65. while(exit != 'e');
    
66. printf("\n记得再来哦!\n");
    
67. } break;
    
68. default : exit(-1);
    
69. }
    
70. printf("欢迎下次光临!\n\n");
    
71. printf("q:quit\tanykey to continue\n\n");
    
72. quit = getch();
    
73. }while(quit != 'q');
    
74. return 0;
    
75. 
    
76. }
    
77. 
    
78. //创建链表函数
    
79. struct node * creat(void)
    
80. {
    
81. int length; //链表的长度
    
82. int variables; //零时变量
    
83. int i; //循环变量
    
84. 
    
85. struct node * phead = (struct node *)malloc(sizeof(struct node));
    
86. //为头指针分配一个没有数据的空间
    
87. 
    
88. if(NULL == phead) //如果头指针分配为空,说明内存没有空间了
    
89. {
    
90. printf("先生,客房已满,欢迎下次光临!");
    
91. exit(-1);
    
92. }
    
93. 
    
94. struct node * ptail = phead; //创建一个尾指针,使头指针的值赋给尾指针
    
95. ptail->next = NULL; //尾指针的后继赋空值
    
96. 
    
97. printf("你想要几位小妞?\n");
    
98. scanf("%d",&length);
    
99. 
    
100. for(i = 0; i < length; i++)
     
101. {
     
102. printf("输入你想要的第%d位小妞的编号: ",i+1);
     
103. scanf("%d",&variables);
     
104. 
     
105. struct node * pnew = (struct node *)malloc(sizeof(struct node));
     
106. 
     
107. if(NULL == pnew)
     
108. {
     
109. printf("先生,客房已满,欢迎下次光临!");
     
110. exit(-1);
     
111. }
     
112. 
     
113. pnew->data = variables; //把输入的数据给新指针的数据域
     
114. ptail->next = pnew; //把新指针的当前地址给尾指针的后继
     
115. pnew->next = NULL; //新指针的后继赋空值
     
116. ptail = pnew; //尾指针移动到新指针的位置,也就是尾指针向后移
     
117. }
     
118. return (phead);
     
119. }//创建链表函数完成
     
120. 
     
121. //链表打印函数
     
122. void print(struct node * phead)
     
123. {
     
124. struct node * p = phead->next; //创建一个p指针指向第一个元素的位置
     
125. 
     
126. while(p)
     
127. {
     
128. printf("%d ",p->data); //输出当前数据
     
129. p = p->next; //p指针向后移
     
130. }
     
131. printf("\n\n");
     
132. }//链表打印函数完成
     
133. 
     
134. //链表插入函数
     
135. void listinsert(struct node * phead)
     
136. {
     
137. struct node * p = phead; //创建查找指针
     
138. 
     
139. int locate=0; //插入位置
     
140. int veriables=0; //插入数据
     
141. int i=1; //循环变量
     
142. struct node * lover = NULL; //建一个情人
     
143. 
     
144. printf("先生,你要把新带来的小妞放在哪?\n");
     
145. scanf("%d",&locate);
     
146. 
     
147. while(p && i<locate) //查找位置
     
148. {
     
149. p=p->next;
     
150. ++i;
     
151. }
     
152. 
     
153. struct node * insert = (struct node *)malloc(sizeof(struct node)); //创建插入节点
     
154. 
     
155. if(NULL == insert)
     
156. {
     
157. printf("先生,客房已满,欢迎下次光临!");
     
158. exit(-1);
     
159. }
     
160. 
     
161. printf("先生,请为你新带来的这位小姐编号:\n");
     
162. scanf("%d",&veriables);
     
163. 
     
164. insert->data = veriables; //赋值给插入结点
     
165. lover = p->next; //用建立的情人lover保存当前地址的后继地址
     
166. p->next = insert; //把插入结点地址给当前指针的后继
     
167. insert->next = lover; //把情人lover保存的地址给插入结点的后继
     
168. print(phead);
     
169. }//插入函数完成
     
170. 
     
171. void listdelete(struct node * phead)
     
172. {
     
173. struct node * p = phead; //创建查找指针p
     
174. 
     
175. int locate=0; //要删除的位置
     
176. int i=1; //循环变量
     
177. int veriables; //保存删除的数据
     
178. 
     
179. struct node * deleter = NULL; //创建一个空指针,用于指向要删除的结点
     
180. 
     
181. printf("你想要带走第几位小妞?\n");
     
182. scanf("%d",&locate);
     
183. 
     
184. while(p && i<locate) //查找删除位置
     
185. {
     
186. p = p->next;
     
187. ++i;
     
188. }
     
189. 
     
190. if(!(p->next) || i>locate)
     
191. {
     
192. printf("先生你找的小妞不在,请另选一位!");
     
193. exit(-1);
     
194. }
     
195. 
     
196. deleter = p->next; //把p的地址后继的地址给零食指针
     
197. p->next = deleter->next ; //删除了p指针后面的一项
     
198. veriables = deleter->data; //把删除的数据保存起来
     
199. free(deleter);
     
200. print(phead);
     
201. printf("被你带走的是%d小妞: \n",veriables);
     
202. }

复制代码

Be_envious

1. #include<stdio.h>
   
2. #include<malloc.h>
   
3. 
   
4. int listlength=0;
   
5. 
   
6. struct node
   
7. {
   
8.        int data;  //数据域
   
9.        struct node *next;  //指针域
   
10. };
    
11. 
    
12. //函数声明
    
13. struct node * creat(void);  //创建链表
    
14. void print(struct node *);  //输出链表
    
15. void listinsert(struct node *);  //插入元素
    
16. void listdelete(struct node *);  //删除元素
    
17. 
    
18. //主函数
    
19. int main(void)
    
20. {
    
21.     //在主函数里创建空的头指针
    
22.     struct node * phead = NULL;
    
23.    
    
24.     phead = creat();  //从头指针开始创建链表
    
25.     printf("\n");
    
26.     char quit;
    
27.     do
    
28.     {
    
29.     char select;
    
30.     printf("输入 p:打印 i:插入 d:删除\n");
    
31.     select = getch();
    
32.     switch(select)
    
33.     {
    
34.                   case 'p' :
    
35.                        {
    
36.                            printf("\n当前小妞总数: %d\n当前可以接客的小妞有:\n",listlength);
    
37.                            print(phead);
    
38.                            printf("\n");
    
39.                        } break;
    
40.                   case 'i' :
    
41.                        {
    
42.                            char exit;
    
43.                            do
    
44.                            {
    
45.                                 printf("在职的小妞:\n");
    
46.                                 print(phead);
    
47.                                 printf("你有多少小妞我全收了!\n");
    
48.                                 listinsert(phead);
    
49.                                 ++listlength;
    
50.                                 printf("当前小妞总数: %d",listlength);
    
51.                                 printf("\ne:退出\t任意键继续\n");
    
52.                                 exit = getch();
    
53.                            }
    
54.                            while(exit != 'e');
    
55.                            printf("\n感谢您为我们带来新的小妞!\n");
    
56.                        } break;
    
57.                   case 'd' :
    
58.                        {
    
59.                            char exit;
    
60.                            do
    
61.                            {
    
62.                                 printf("在职的小妞:");
    
63.                                 print(phead);
    
64.                                 printf("我们这里有很多小妞,你可以随意的挑选!\n");
    
65.                                 listdelete(phead);
    
66.                                 --listlength;
    
67.                                 printf("当前小妞总数: %d",listlength);
    
68.                                 printf("\ne:退出\t任意键继续\n");
    
69.                                 exit = getch();
    
70.                            }
    
71.                            while(exit != 'e');
    
72.                            printf("\n记得再来哦!\n");
    
73.                        } break;
    
74.                   default : exit(-1);
    
75.     }
    
76.     printf("欢迎下次光临!\n\n");
    
77.      printf("q:quit\tanykey to continue\n\n");
    
78.      quit = getch();
    
79.     }while(quit != 'q');
    
80.     return 0;
    
81.      
    
82. }
    
83. 
    
84. //创建链表函数
    
85. struct node * creat(void)
    
86. {      
    
87.        int length;  //链表的长度
    
88.        int variables;  //零时变量
    
89.        int i;  //循环变量
    
90.       
    
91.        struct node * phead = (struct node *)malloc(sizeof(struct node));
    
92.        //为头指针分配一个没有数据的空间
    
93.       
    
94.         if(NULL == phead)  //如果头指针分配为空,说明内存没有空间了
    
95.         {
    
96.                 printf("先生,客房已满,欢迎下次光临!");
    
97.                 exit(-1);
    
98.         }
    
99.         
    
100.         struct node * ptail = phead;   //创建一个尾指针,使头指针的值赋给尾指针
     
101.         ptail->next = NULL;  //尾指针的后继赋空值
     
102.         
     
103.         printf("你想要几位小妞?\n");
     
104.         scanf("%d",&length);
     
105.         listlength = length;
     
106.         
     
107.         for(i = 0; i < length; i++)
     
108.         {
     
109.               printf("输入你想要的第%d位小妞的编号: ",i+1);
     
110.               scanf("%d",&variables);
     
111.               
     
112.               struct node * pnew = (struct node *)malloc(sizeof(struct node));
     
113.               
     
114.               if(NULL == pnew)
     
115.               {
     
116.                       printf("先生,客房已满,欢迎下次光临!");
     
117.                       exit(-1);
     
118.               }
     
119.               
     
120.               pnew->data = variables;  //把输入的数据给新指针的数据域
     
121.               ptail->next = pnew;  //把新指针的当前地址给尾指针的后继
     
122.               pnew->next = NULL;  //新指针的后继赋空值
     
123.               ptail = pnew;  //尾指针移动到新指针的位置,也就是尾指针向后移
     
124.         }
     
125.         return (phead);
     
126. }//创建链表函数完成
     
127. 
     
128. //链表打印函数
     
129. void print(struct node * phead)
     
130. {
     
131.       struct node * p = phead->next;  //创建一个p指针指向第一个元素的位置
     
132.       
     
133.       while(p)
     
134.       {
     
135.               printf("%d ",p->data); //输出当前数据
     
136.               p = p->next;  //p指针向后移
     
137.       }
     
138.       printf("\n\n");
     
139. }//链表打印函数完成
     
140. 
     
141. //链表插入函数
     
142. void listinsert(struct node * phead)
     
143. {
     
144.      struct node * p = phead; //创建查找指针
     
145.      
     
146.      int locate=0;  //插入位置
     
147.      int veriables=0;  //插入数据
     
148.      int i=1;  //循环变量
     
149.      struct node * lover = NULL; //建一个情人
     
150.      
     
151.      printf("先生,你要把新带来的小妞放在哪?\n");
     
152.      scanf("%d",&locate);
     
153.      
     
154.      while(p && i<locate) //查找位置
     
155.      {
     
156.               p=p->next;
     
157.               ++i;
     
158.      }
     
159.      
     
160.      struct node * insert = (struct node *)malloc(sizeof(struct node)); //创建插入节点
     
161.      
     
162.      if(NULL == insert)
     
163.      {
     
164.              printf("先生,客房已满,欢迎下次光临!");
     
165.              exit(-1);
     
166.      }
     
167.      
     
168.      printf("先生,请为你新带来的这位小姐编号:\n");
     
169.      scanf("%d",&veriables);
     
170.      
     
171.      insert->data = veriables;  //赋值给插入结点
     
172.      lover = p->next;  //用建立的情人lover保存当前地址的后继地址
     
173.      p->next = insert;  //把插入结点地址给当前指针的后继
     
174.      insert->next = lover;   //把情人lover保存的地址给插入结点的后继
     
175.      print(phead);
     
176. }//插入函数完成
     
177. 
     
178. void listdelete(struct node * phead)
     
179. {
     
180.      struct node * p = phead;  //创建查找指针p
     
181.      
     
182.      int locate=0; //要删除的位置
     
183.      int i=1;  //循环变量
     
184.      int veriables;  //保存删除的数据
     
185.      
     
186.      struct node * deleter = NULL; //创建一个空指针,用于指向要删除的结点
     
187.      
     
188.      printf("你想要带走第几位小妞?\n");
     
189.      scanf("%d",&locate);
     
190.      
     
191.      while(p && i<locate)  //查找删除位置
     
192.      {
     
193.               p = p->next;
     
194.               ++i;
     
195.      }
     
196.      
     
197.      if(!(p->next) || i>locate)
     
198.      {
     
199.                    printf("先生你找的小妞不在,请另选一位!");
     
200.                    exit(-1);
     
201.      }
     
202.      
     
203.      deleter = p->next;  //把p的地址后继的地址给零食指针
     
204.      p->next = deleter->next ; //删除了p指针后面的一项
     
205.      veriables = deleter->data;  //把删除的数据保存起来
     
206.      free(deleter);
     
207.      print(phead);
     
208.      printf("被你带走的是%d小妞: \n",veriables);
     
209. }

复制代码

sdlicong

好东西，谢谢分享，学习了~~~

朗朗

写struct node好麻烦，用typedef定义，这样不麻烦。

丿夏夜灬彬刂

有创新啊 学习学习咯 嘿嘿

梦幻羽羽

单链表么？    你是学c版的  数据结构吧~   在链表这里， 你只要注意节点之间的关系的存储和数据存储  好好掌握住，还有就是你这 listdelete  这删除链表的元素这里是通过while 和 if 的配合来确定删除元素的确定的  但是 这样大大增加时间复杂度    有种方法可以大大减少时间复杂度。 希望你想想，  对了别的地方还是有些问题的你在看看， 说的不好的地方，请见谅{:1_1:}

Cocol

看看学习学习