用C++实现单链表的创建、逆置和输出 的两种方法

http://blog.csdn.net/lfeng_coding/article/details/47300563

题目描述：在已知单链表头节点的情况下，设计算法逆置单链表并输出

方法一：采用首先将头节点指向空，让其变为尾节点，然后利用中间节点 p、q 将其后的节点一个接一个改为指向前面的节点

/****************************

*作者：刘峰

* 时间：2015\8\5

* 环境：VS2013

* 功能：实现创建一个节点可控的单链，并逆置输出

****************************/

[cpp] view plain copy

1. #include "stdafx.h"  
2.   
3. #include <iostream>  
4. using namespace std;  
5.   
6. struct List  
7. {  
8.     int num;  
9.     List *next;  
10. };  
11.   
12. List *createList(int n)       //创建含有n个节点的单链表  
13. {  
14.     List *head, *p, *q;  
15.     q=head = NULL;   //初始化表头和中间指针  
16.     int i;  
17.     for (i = n; i > 0; --i)  
18.     {  
19.         p = new List;     //申请空间，创建第一个节点  
20.         cin >> p->num;      //往节点中存入数据信息  
21.         if (head == NULL)  
22.         {  
23.             head = p;  
24.         }  
25.         else  
26.         {  
27.             q->next = p;  
28.         }  
29.         q = p;  
30.     }  
31.     q->next = NULL;  
32.     return head;  
33. }  
34.   
35. List *ReverseList(List *head)          //逆置单链表  
36. {  
37.     List *p, *r;       //定义两个中间节点，用于顺移逆置链表节点  
38.     if (head->next == NULL)  
39.         return head;  
40.     p = head;          //获取头节点地址  
41.     r = p->next;       //获取链表第二个节点地址  
42.     p->next = NULL;    //头节点变为尾节点，原链表表头指向空  
43.     while (r)  
44.     {  
45.         p = r;  
46.         r = r->next;  
47.         p ->next = head;   //使第二个节点指向原先的头节点  
48.         head = p;          //使第二个节点变为头节点，用于循环逆置  
49.     }  
50.     return head;  
51. }  
52.   
53. void print(List *head)        //输出逆置后的单链表  
54. {  
55.     List *p;  
56.     p = head;  
57.     while (p)  
58.     {  
59.         cout<<p->num;  
60.         p = p->next;  
61.         cout << " ";  
62.     }  
63.     cout << endl;  
64. }  
65. int _tmain(int argc, _TCHAR* argv[])  
66. {  
67.     List *p, *q;  
68.     cout << "请输入单链表的节点个数：";  
69.     int n;  
70.     cin >> n;  
71.     cout << endl;  
72.     cout << "创建一个节点为" << n << "的单链表" << endl;  
73.     p = createList(n);  
74.     cout << endl;  
75.     cout << "这步为程序逆置单链表" << endl;  
76.     q = ReverseList(p);  
77.     cout << endl;  
78.     cout << "打印逆置后的单链表" << endl;  
79.     print(q);  
80.     cout << endl;  
81.     return 0;  
82. }  

方法二：用p,q指向单链表中相邻的两节点，将r指向q的下一个结点，然后同步后移。当q=NULL时，表示指向原单链表的尾结点，将p赋值为头节点 head 即可。

逆置函数代码如下（其他部分不变）：

List *ReverseList(List *head)
{
List *p, *q, *r;
p = head;
if (p->next == NULL)
return head;
q = p->next;
while (q != NULL)     //q为空，说明p为最后一个节点，所以结束while后将q赋值给head,作为逆置后的表头
{
r = q->next;
q->next = p;
p = q;
q = r;
}
head->next = NULL;   //将原head变为逆置后链表的表尾
head = p;            //逆置后新的表头
return head;
}