链表逆置

链表逆置：
1：先用一个newroot指向链表头结点；
2：用curr指向头结点的下一个节点，nextnode指向curr的下一个节点，用来更新curr；
3：断开头结点与链表的链接；
4：循环头插法把curr插入newnode为头结点的链表；
5：curr更新为下一个节点；

代码如下：

#include<stdio.h>
#include<stdlib.h>

typedef struct Node
{ int data; struct Node*next;
}Node, *Ls;
Node*BuyNode(Node*p)
{ p = (Node*)malloc(sizeof(Node)); if(p==NULL)exit(-1); p->next = NULL; return p;
}
//
Node*CreateNode(int val)
{ Node*p = (Node*)malloc(sizeof(Node)); if(p==NULL)exit(-1); p->data = val; p->next =NULL; return p;
}

Node* Init(Node* p)//初始化，malloc一个头结点
{ return BuyNode(p);
}

void Insert(Ls list, int val)//头插法
{ Node *p = CreateNode(val); p->next = (list)->next; (list)->next = p;

}

void show(Ls list)
{ if(list==NULL) { return ; } Node *p = (list)->next; for( ; p !=NULL; p=p->next) { printf("%d  ",p->data); } printf("\n");
}
//逆置
void Reverse(Node*ls)
{ if(ls==NULL) { return ; } Node*newroot = ls;//newroot指向原来的头结点； Node*curr = ls->next;//curr指向头结点的下一个节点； Node*nextnode = NULL;//声明curr的下一个节点 newroot->next = NULL;//断开的头结点与原来的链表，next域置为空； while(curr != NULL) { nextnode = curr->next;//curr的下一个节点 curr->next = newroot->next;//连接到新的头结点； newroot->next = curr; curr = nextnode; //原来的结点向后移动  } }

int main()
{ Node root; Node* p  =Init(&root);//头结点 for(int i=0;i<10;++i) { Insert(p,i); } show(p); Reverse(p); show(p); return 0;
}
  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
 

结果：
9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9
请按任意键继续…

文章来源: blog.csdn.net，作者：IM-STONE，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/doubleintfloat/article/details/52724498