单链表逆置、正向排序、打印、寻找中间元素

单链表逆置原理：

头插法：

0（初始化）、q为每一步运算的主要节点位置，初始化为第一个；

1、r=q的后续，把q的后续记录下来；

2、q-》next=p，把q的后续指向p（也就是开始），换句话说，把q放在了最开始；

3、p=q，把新的开始设置为新插入的q（下一次循环时，他就是p了）；

4、q=r，把下一步要进行运算的主要节点设置为r，也就是当前运算节点的下个节点。

相当于，一队小朋友双手搭着前一个人的肩。从第二个开始，把他挪到第一个人前面去，然后对下一个人做同样操作。

[cpp] view plain copy print ?

1. // 单链表.cpp : 定义控制台应用程序的入口点。
2. //单链表
3. #include "stdafx.h"
4. #include <iostream>
5. #include <complex>
6. using namespace std;
8. typedef struct node {
9. int data;//节点内容
10. node *next;//下一个节点
11. }node;
13. //单链表的正向排序
14. node *InsertSort(){
15. node *head,*p,*q,*cur;
16. int a=-1;
17. head=new node;
18. head->next=NULL;
19. while (1)
20. {
21. cout<<"please input the data(-1,quit):";
22. cin>>a;
23. if (-1==a){ //输入-1结束
24. break;
25. }
26. p=new node;
27. p->data=a;
28. p->next=NULL;
29. q=head->next;
30. if (q==NULL){//如果第一个节点为NULL，则对第一个节点赋值
31. head->next=p;
32. continue;
33. }
34. if (q->data>a){//如果插入值小于第一个节点，则插入到head之后
35. p->next=head->next;
36. head->next=p;
37. }
38. else{ //如果插入值大于等于第一个节点
39. while (q->data<a){
40. cur=q;
41. q=q->next;
42. if (q==NULL){ //如果到了末尾，则跳出循环
43. break;
44. }
45. }
46. if (q==NULL){ //如果到了末尾,直接插入到末节点后面
47. cur->next=p;
48. }
49. p->next=q; //插入值插到q前面，cur后面
50. cur->next=p;
51. }
52. }
53. return head;
54. }
56. //打印单链表
57. void print(node *head){
58. node *p=head->next;
59. int index=0;
60. if (p==NULL)//链表为NULL
61. {
62. cout<<"Link is empty!"<<endl;
63. getchar();
64. return;
65. }
66. while (p!=NULL)//遍历链表
67. {
68. cout<<"The "<<++index<<"th node is :"<<p->data<<endl;//打印元素
69. p=p->next;
70. }
71. }
73. //单链表逆置
74. node *reverse(node *head){
75. node *p,*q,*r;
76. if (head->next==NULL)//链表为空
77. {
78. return head;
79. }
80. p=head->next;
81. q=p->next;//保存原第2个节点
82. p->next=NULL;//原第1个节点为末节点
83. while (q!=NULL)//遍历，各个节点的next指针反转
84. {
85. r=q->next;
86. q->next=p;
87. p=q;
88. q=r;
89. }
90. head->next=p;//新的第一个节点为原末节点
91. return head;
92. }
94. //寻找单链表的中间元素
95. node *search_mid(node *head){
96. node *current=NULL; //current指向当前已扫描链表的尾节点
97. node *mid=NULL; //mid指向当前已经扫描的子链表的中间元素
98. int i=0,j=0;
99. current=mid=head->next;//都指向第一个节点
100. while (current!=NULL){
101. if (i/2>j)
102. {
103. j++;
104. mid=mid->next;
105. }
106. i++;
107. current=current->next;
108. }
109. return mid;
110. }
112. int _tmain(int argc, _TCHAR* argv[])
113. {
114. node *head=InsertSort();//创建单链表
115. cout<<"--------after insertSort()------------"<<endl;
116. print(head);
117. node *preverse=reverse(head);
118. cout<<"--------after reverse()------------"<<endl;
119. print(preverse);
120. node *p=search_mid(head);
121. cout<<"--------after search_mid()------------"<<endl;
122. cout<<"search_mid():"<<p->data<<endl;
123. system("pause");
124. delete [] head;
125. return 0;
126. }

// 单链表.cpp : 定义控制台应用程序的入口点。
//单链表
#include "stdafx.h"
#include <iostream>
#include <complex>
using namespace std;

typedef struct node {
	int data;//节点内容
	node *next;//下一个节点
}node;

//单链表的正向排序
node *InsertSort(){
	node *head,*p,*q,*cur;
	int a=-1;
	head=new node;
	head->next=NULL;
	while (1)
	{
		cout<<"please input the data(-1,quit):";
		cin>>a;
		if (-1==a){ //输入-1结束
			break;
		}
		p=new node;
		p->data=a;
		p->next=NULL;
		q=head->next;
		if (q==NULL){//如果第一个节点为NULL，则对第一个节点赋值
			head->next=p;
			continue;
		}
		if (q->data>a){//如果插入值小于第一个节点，则插入到head之后
			p->next=head->next;
			head->next=p;
		}
		else{    //如果插入值大于等于第一个节点
			while (q->data<a){
				cur=q;
				q=q->next;
				if (q==NULL){ //如果到了末尾，则跳出循环
					break;
				}
			}
			if (q==NULL){ //如果到了末尾,直接插入到末节点后面
				cur->next=p;
			}
			p->next=q; //插入值插到q前面，cur后面
			cur->next=p;
		}
	}
	return head;
}

//打印单链表
void print(node *head){
	node *p=head->next;
	int index=0;
	if (p==NULL)//链表为NULL
	{
		cout<<"Link is empty!"<<endl;
		getchar();
		return;
	}
	while (p!=NULL)//遍历链表
	{
		cout<<"The "<<++index<<"th node is :"<<p->data<<endl;//打印元素
		p=p->next;
	}
}

//单链表逆置
node *reverse(node *head){
	node *p,*q,*r;
	if (head->next==NULL)//链表为空
	{
		return head;
	}
	p=head->next;
	q=p->next;//保存原第2个节点
	p->next=NULL;//原第1个节点为末节点
	while (q!=NULL)//遍历，各个节点的next指针反转
	{
		r=q->next;
		q->next=p;
		p=q;
		q=r;
	}
	head->next=p;//新的第一个节点为原末节点
	return head;
}

//寻找单链表的中间元素
node *search_mid(node *head){
	node *current=NULL; //current指向当前已扫描链表的尾节点
	node *mid=NULL; //mid指向当前已经扫描的子链表的中间元素
	int i=0,j=0;
	current=mid=head->next;//都指向第一个节点
	while (current!=NULL){		  
		 if (i/2>j)
		 {
			 j++;
			 mid=mid->next;
		 }
            i++;
		current=current->next;
	}
	return mid;
}

int _tmain(int argc, _TCHAR* argv[])
{
	node *head=InsertSort();//创建单链表
	cout<<"--------after insertSort()------------"<<endl;
	print(head);
	node *preverse=reverse(head);
	cout<<"--------after reverse()------------"<<endl;
	print(preverse);
	node *p=search_mid(head);
	cout<<"--------after search_mid()------------"<<endl;
	cout<<"search_mid():"<<p->data<<endl;
	system("pause");
	delete [] head;
	return 0;
}