有序单链表的合并

原文链接：谢谢作者

1  非递归方式：

[cpp]  view plain copy

1. // 单链表.cpp : 定义控制台应用程序的入口点。  
2. //单链表  
3. #include "stdafx.h"  
4. #include <iostream>  
5. #include <complex>  
6. using namespace std;  
7.   
8. typedef struct node {  
9.     int data;//节点内容  
10.     node *next;//下一个节点  
11. }node;  
12.   
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. }  
55.   
56. //两个有序单链表进行合并  
57. node *merge(node *head1,node *head2){  
58.     if (head1==NULL || head1->next==NULL)  
59.     {  
60.         return head2;  
61.     }  
62.     if (head2==NULL || head2->next==NULL)  
63.     {  
64.         return head1;  
65.     }  
66.     node *head; //合并后的头指针  
67.     head=new node;   
68.     head->next=NULL;  
69.     node *p,*q;  
70.     node *p1=head1->next;//p1指向head1的第一个节点  
71.     node *p2=head2->next;//p2指向head2的第二个节点  
72.       q=head;//q指向合并后的单链表  
73.     while (p1!=NULL && p2!=NULL){  
74.         if (p1->data<=p2->data){ //如果p1指向的节点值小则插入其对应值  
75.             p=new node;   
76.             p->next=NULL;  
77.             p->data=p1->data;  
78.             q->next=p;  
79.             q=q->next; //q指向新末节点  
80.             p1=p1->next;//p1 指向下一个节点  
81.         }  
82.         else{ //否则插入p2指向节点对应值  
83.                 p=new node;  
84.                 p->data=p2->data;  
85.                 p->next=NULL;  
86.                 q->next=p;  
87.                 q=q->next;//q指向新末节点  
88.                 p2=p2->next;//p2 指向下一个节点  
89.             }  
90.     }  
91.   
92.     if (p1!=NULL) //如果p1指向的单链表没有插入完，则把剩余的插入到q的后面  
93.     {  
94.         while (p1!=NULL)  
95.         {  
96.             p=new node;  
97.             p->data=p1->data;  
98.             p->next=NULL;  
99.             q->next=p;  
100.             q=q->next;  
101.             p1=p1->next;  
102.         }  
103.     }  
104.     if (p2!=NULL)//如果p2指向的单链表没有插入完，则把剩余的插入到q的后面  
105.     {  
106.         while (p2!=NULL)  
107.         {  
108.             p=new node;  
109.             p->data=p2->data;  
110.             p->next=NULL;  
111.             q->next=p;  
112.             q=q->next;  
113.             p2=p2->next;  
114.         }  
115.     }  
116.     return head; //返回合并后单链表的头指针  
117. }  
118.   
119. //打印单链表  
120. void print(node *head){  
121.     node *p=head->next;  
122.     int index=0;  
123.     if (p==NULL)//链表为NULL  
124.     {  
125.         cout<<"Link is empty!"<<endl;  
126.         getchar();  
127.         return;  
128.     }  
129.     while (p!=NULL)//遍历链表  
130.     {  
131.         cout<<"The "<<++index<<"th node is :"<<p->data<<endl;//打印元素  
132.         p=p->next;  
133.     }  
134. }  
135.   
136. int _tmain(int argc, _TCHAR* argv[])  
137. {  
138.     node *head1=InsertSort();//创建单链表  
139.     node *head2=InsertSort();//创建单链表  
140.     node *head=merge(head1,head2);  
141.     cout<<"after merge:"<<endl;  
142.     print(head);  
143.     system("pause");  
144.     delete [] head1;  
145.     delete [] head2;  
146.     delete [] head;  
147.     return 0;  
148. }