C语言反转单链表

1、反转单链表

        定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。链表结点定义如下：

        struct node //结点类型定义
        {
                int val; //结点的数据域
                struct node *pNext;//结点的指针域（存放结点的直接后继的地址）
      };

2、链表的结点结构

┌───┬───┐

│ data │ next │

└───┴───┘

data域 --  存放结点值的数据域

next域 --  存放结点的直接后继的地址 （位置）的 指针 域（链域）

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. struct node  
5. {  
6.     int val;  
7.     struct node *pNext;  
8. };  
9.   
10. struct node *gen()  
11. {  
12.     struct node *pHead = NULL;  
13.     printf("反转前::");
14.     for(int i = 10; i > 0; i--){  
15. // 创建了一个空节点并分配内存，此时此节点还没有数据,为空节点
16.         struct node * p = (struct node *)malloc(sizeof(struct node)); 
17.        //在空节点的data域赋值
18.         p -> val = i;  
19.        //因为pHead初始化时为NULL，第一次for循环表示是第一个节点（后面无其他节点），p->pNext的下个节点为NULL空
20.         p -> pNext = pHead;  
21.         //将已填充好的第一次分配的节点p赋值给pHead，此时pHead不为空，以此循环翻转链表
22.         pHead = p;  
23.         printf("%d ",i);
24.     }     
25.         printf("\n");
26. 
    
27.     return pHead;  
28. }  
29.   
30. void display(struct node *pHead)  
31. {  
32.     printf("反转后::");
33.     while( pHead != NULL)  
34.     {     
35.         printf("%d ", pHead->val);  
36.         pHead = pHead->pNext;  
37.     }     
38.     printf("\n");  
39. }  
40.   
41. //递归实现  
42. struct node * reverse(struct node *pHead)  
43. {  
44.     if (pHead == NULL || pHead -> pNext == NULL)  
45.     {     
46.         return pHead;  
47.     }     
48.     struct node *p = pHead -> pNext;  
49.     struct node *pNewHead =  reverse(p);  
50.     p -> pNext = pHead;  
51.     pHead ->pNext = NULL;  
52.     return pNewHead;  
53. }  
54.   
55. //尾递归实现  
56. struct node * do_reverse_tail(struct node *pHead, struct node *pNewHead)  
57. {  
58.     if(pHead == NULL)  
59.     {  
60.         return pNewHead;  
61.     }  
62.     else  
63.     {  
64.         struct node *pNext = pHead->pNext;  
65.         pHead->pNext = pNewHead;  
66.         return do_reverse_tail(pNext, pHead);  
67.     }  
68. }  
69.   
70. struct node * reverse_tail(struct node *pHead)  
71. {  
72.     return do_reverse_tail(pHead, NULL);  
73. }  
74.   
75. //迭代实现  
76. struct node * reverse_it(struct node *pHead)  
77. {  
78.     struct node *pNewHead = NULL;  
79.     struct node *pPrev = NULL;  
80.     struct node *pCur = pHead;  
81.     while(pCur != NULL)  
82.     {  
83.         struct node *pTmp = pCur->pNext;  
84.         if(pTmp == NULL)  
85.         {  
86.             pNewHead = pCur;  
87.         }  
88.         pCur->pNext = pPrev;  
89.         pPrev = pCur;  
90.         pCur = pTmp;  
91.     }  
92.   
93.     return pNewHead;  
94. }  
95.   
96. int main()  
97. {  
98.     struct node *pHead = gen();  
99.     display(pHead);  
100.     pHead = reverse_it(pHead);  
101.     display(pHead);  
102. }