简单的链表代码

一个师弟的简单的链表代码（经过修改）。嗯，应该是学习链表的实例代码吧。

1. // testlist.cpp : Defines the entry point for the console application.
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <stdio.h>
7. #include <malloc.h>
9. using namespace std;
11. /*一、    插入链表。一个链表A={a1,a2,..,an}结构如下：
13. 节点定义为：
14. struct node{
15. int num;        //关键字
16. struct node *next;
17. }；
18. 编程。要求程序实现如下功能：
19. （1）    插入链表。主程序输入关键码值，调用插入函数insert()，将节点插入到A中；
20. （2）    遍历节点计数。调用节点计数函数counter()，遍历求A中的节点个数。调用counter()函数之后，其返回值（整数）输出到屏幕；
21. （3）    递归节点计数。调用递归函数Rcounter()，递归求A中的节点个数，调用Rcounter()函数之后，其返回值（整数）输出到屏幕；
24. 我的case 3 为什么总输出0啊？？？
25. 其他都能运行，就递归（Rcounter）不行？为什么
26. */
28. struct node{
29.     int num;
30.     struct node *next;
31. };
32. int counter(struct node *);
33. int Rcounter(struct node *,int*);
34. struct node *insert(struct node *,struct node *);
36. int main()
37. {
38.     struct node *head=NULL,*node1;
39.     int k;
40.     cout<<"输入要执行的功能：1 插入节点 2 遍历计数 3 递归计数 4 退出程序"<<endl;
41.     cin>>k;
42.     node1=(struct node *)malloc(sizeof(struct node));
43.     while(k!=4)
44.     {
45.         switch(k)
46.         {
47.         case 1:
48.             cout<<"输入关键码值："<<endl;
49.             cin>>node1->num;
50.             head=insert(head,node1);
51.             break;
52.         case 2:
53.             int i;
54.             i=counter(head);
55.             cout<<"共有"<<i<<"个节点"<<endl;
56.             break;
57.         case 3:
58.             struct node *s;
59.             node* pNode = NULL;
61.             int t=0;
62.             int k=0;
64.             //s=head; 由于下面是动态内存分配的所以你这里赋值是没有什么意义的           
66.             head = (struct node *)malloc(sizeof(struct node));
67.             //判断是否动态内存分配成功
68.             if (NULL == head)
69.             {
70.                 cout << "get memory failed!";
71.                 break;
72.             }
74.             //初始化
75.             head->next = NULL;
77.             //对于链表的头需要单独的处理
78.             cout<<"是否输入关键字：1是 0否"<<endl;
79.             cin>>k;
81.             if (0 == k)
82.             {
83.                 cout << "递归求得的节点数是 0" << endl;
84.                 break;
85.             }
86.             else
87.             {
88.                 head->num = k;
89.             }
90.                 
91.             //动态内存分配了之后再赋值
92.             s = head; //这样 head 里面保存了头了
93.             
94.             //开始建立链表
95.             while(k)
96.             {    
97.                 pNode = (struct node *)malloc(sizeof(struct node));
99.                 //判断是否动态内存分配成功
100.                 if (NULL == pNode)
101.                 {
102.                     cout << "get memory failed!";
103.                     break;
104.                 }
106.                 //初始化
107.                 pNode->next = NULL;
108.                 
109.                 cout<<"输入num:"<<endl;
110.                 cin>> pNode->num;
111.                 cout<<"是否继续输入：1是 0否"<<endl;
112.                 cin>>k;
113.                 if(k)
114.                 {    
115.                     //下面的语句是建立链表的关键代码
116.                     //s=s->next;
117.                     s->next = pNode;
118.                     s = pNode;
119.                 }
120.             }
122.             //建立链表结束
123.             s=head;
124.             t = 0;
126.             //Rcounter 函数是需要改变t的，所以参数应该传递指针，当然你的做法也可以，但是需要修改一个很微小的地方
127.             cout<<"递归求得的节点数是："<< Rcounter(s, &t) << endl;
128.         }
130.         cout<<"输入要执行的功能：1 插入节点 2 遍历计数 3 递归计数 4 退出程序"<<endl;
131.         cin>>k;
132.     }
133.     if(k==4)
134.     {
135.         cout<<"谢谢!"<<endl;
136.     }
137.     return 0;
138. }
140. struct node *insert(struct node *head,struct node *node1)
141. {
142.     struct node *p0,*p1,*p2;
143.     p1=head;
144.     p0=node1;
145.     if(head==NULL)
146.     {
147.         head=p0;
148.         p0->next=NULL;
149.     }
150.     else
151.     {
152.         while(p0->num > p1->num)
153.         {
154.             p2=p1;
155.             p1=p1->next;
156.         }
157.         if(p0->num<=p1->num)
158.         {
159.             if(head==p1)head=p0;
160.             else p2->next=p0;
161.             p0->next=p1;
162.         }
163.         else
164.         {
165.             p1->next=p0;
166.             p0->next=NULL;
167.         }
168.     }
169.     return (head);
170. }
174. int counter(struct node *head)
175. {
176.     int k=0,i=0;
177.     cout<<"是否输入节点关键字：1是 0否"<<endl;
178.     cin>>k;
179.     while(k)
180.     {
181.         head=(struct node *)malloc(sizeof(struct node));
182.         cout<<"输入num："<<endl;
183.         cin>>head->num;
184.         cout<<"是否继续输入节点关键字：1是 0否"<<endl;
185.         cin>>k;
186.         if(k)
187.         {    
188.             head=head->next;
189.             i++;
190.         }
191.     }
193.     if(head==NULL)
194.     {
195.         cout<<"链表为空"<<endl;
196.         return 0;
197.     }
198.     return i+1;
199. }
202. int Rcounter(struct node *s,int* pt)
203. {
204.     if (NULL == s)
205.     {
206.         return *pt;
207.     }
208.     else
209.     {
210.         (*pt)++;
211.         return Rcounter(s->next, pt);
212.     }
214. }