合并两个有序的链表

题目：已知有两个有序的单链表，其头指针分别为head1和head2，实现将这两个链表合并的函数：

          Node* ListMerge(Node *head1,Node *head2)

算法的递归实现如下：

<span style="font-size:14px;">Node *ListMerge1(Node *head1,Node *head2)//采用递归的方法实现
{
	if(head1==NULL)
		return head2;
	if(head2==NULL)
		return head1;
	Node *head=NULL;
	if(head1->value < head2->value)
	{
		head=head1;
		head->next=ListMerge1(head1->next,head2);
	}
	else
	{
		head=head2;
		head->next=ListMerge1(head1,head2->next);
	}
	return head;
}</span>

算法的非递归实现如下：

Node *ListMerge(Node *head1,Node *head2)
{
	if(!head1) return head2;
	if(!head2) return head1;
	Node *head=NULL;//合并后的头指针
	Node *p1=head1;//p1用于扫描链表1
	Node *p2=head2;//p2用于扫描链表2
	if(head1->value<head2->value)
	{
		head=head1;
		p1=head1->next;
	}
	else
	{
		head=head2;
		p2=head2->next;
	}
	Node *p=head;//p永远指向最新合并的结点
	while(p1 && p2)//如果循环停止，则p1或p2至少有一个为NULL
	{
		if(p1->value<p2->value)
		{
			p->next=p1;
			p1=p1->next;
		}
		else
		{
			p->next=p2;
			p2=p2->next;
		}
		p=p->next;
	}
	if(p1)//如果链1还没走完
	{
		p->next=p1;
	}
	else if(p2)//如果链2还没走完
	{
		p->next=p2;
	}
	return head;
}

（虚拟节点） 

        这种方法用一个虚拟节点（dummy node）作为结果链表的起始节点，为了方便在链表尾部插入节点，还需要用一个尾指针指向链表的尾节点。

        初始时，结果链表为空的时候，尾指针指向的是虚拟节点。因为虚拟节点是一个在栈上分配的临时变量，所以对它的操作都是非常高效的。在循环迭代中，每次从a或b中取一个节点插入到结果链表的尾部，循环结束时，虚拟节点的next域就是结果链表的地址，也就是我们期望的返回值。

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <assert.h>  
4.   
5. /*Link list node*/  
6. struct node  
7. {  
8.     int data;  
9.     struct node* next;  
10. };  
11.   
12. /*Function to insert a node at the begining of the linked list*/  
13. void push(struct node** head_ref, int new_data)  
14. {  
15.     /* allocate node*/  
16.     struct node* new_node = (struct node*)malloc(sizeof(struct node));  
17.       
18.     /* put in the data*/  
19.     new_node->data = new_data;  
20.       
21.     /*link the old list off the new node*/  
22.     new_node->next = (*head_ref);  
23.   
24.     /*move the head to point to the new node*/  
25.     (*head_ref) = new_node;  
26. }  
27.   
28. /* Function to print nodes in a given linked list */  
29. void printList(struct node* node)  
30. {  
31.     while(node != NULL)  
32.     {  
33.         printf("%d ", node->data);  
34.         node = node->next;  
35.     }  
36.     printf("\n");  
37. }  
38.   
39. /*pull off the front node of the source and put it in dest*/  
40. /* MoveNode() function takes the node from the front of the source, and move it to  
41. the front of the dest. 
42. It is an error to call this with the source list empty. 
43.  
44.     Before calling MoveNode(): 
45.     source == {1, 2, 3} 
46.     dest == {1, 2, 3} 
47.      
48.     After calling MoveNode(): 
49.     source == {2, 3} 
50.     dest == {1, 1, 2, 3} 
51. */  
52.   
53. void MoveNode(struct node** destRef, struct node** sourceRef)  
54. {  
55.     /* the front source node */  
56.     struct node* newNode = *sourceRef;  
57.     assert(newNode != NULL);  
58.       
59.     /*Advance the source pointer */  
60.     *sourceRef = newNode->next;  
61.       
62.     /* Link th eold dest off the new node */  
63.     newNode->next = *destRef;  
64.   
65.     /*Move dest to point to the new node */  
66.     *destRef = newNode;  
67. }  
68.   
69. /*Takes two lists sorted in creasing order, and splices their nodes together to  
70. make ont big sorted list which is returned. */  
71. struct node* SortedMerge(struct node* a, struct node* b)  
72. {  
73.     /* a dummy first node to hang the result on */  
74.     struct node dummy;  
75.       
76.     /* tail points to the last result node */  
77.     struct node* tail = &dummy;  
78.       
79.     /*so tail->next is the places to add new nodes to the result*/  
80.     dummy.next = NULL;  
81.     while(1)  
82.     {  
83.         if(a == NULL)  
84.         {  
85.             tail->next = b;  
86.             break;  
87.         }  
88.         else if(b == NULL)  
89.         {  
90.             tail->next = a;  
91.             break;  
92.         }  
93.   
94.         if(a->data <= b->data)  
95.         {  
96.             MoveNode(&(tail->next), &a);  
97.         }  
98.         else  
99.         {  
100.             MoveNode(&(tail->next), &b);  
101.         }  
102.         tail = tail->next;  
103.     }     
104.     return (dummy.next);  
105. }  
106. /*Drier program to test above functions */  
107. int main(int argc, char* argv[])  
108. {  
109.   
110.     /*start with the empty list */  
111.     struct node* res = NULL;  
112.     struct node* a = NULL;  
113.     struct node* b = NULL;  
114.   
115.     /*Let us create two sorted linked lists to test the functions  
116.     Created lists shall be a:5->10->15, b:2->3->20 */  
117.   
118.     push(&a, 15);  
119.     push(&a, 10);  
120.     push(&a, 5);  
121.   
122.     push(&b, 20);  
123.     push(&b, 3);  
124.     push(&b, 2);  
125.   
126.     res = SortedMerge(a, b);  
127.     printf("\nMerged Linked List is:\n");  
128.     printList(res);  
129.     return 0;  
130. }