链表合并

题目： 输入两个递增排序的链表，要求把两个链表和并成一个链表并且使得新链表也是递增排序的。

分析：

1. 假设两个链表如下所示

    

2. 要合并两个链表，可以利用归并排序的合并思想，从头枚举两个链表，判断两个指针指向的两个结点的值关系。

   （1）初始化两个指针p1，p2分别指向两个链表的头结点，合并之后新的链表头结点肯定是两个链表中值较小的那个

   （2）每一次比较两个指针指向的结点值的大小，如果p1较小则把p1指向结点加入新链表，否则加入p2指向的结点。直到有一个链表为空，然后把剩下的所有结点全部加入新链表即可

3. 代码（归并排序思想）

[cpp] view plaincopy

1. //链表结点  
2. struct ListNode{  
3.     int value;  
4.     ListNode *nextNode;  
5. };   
6.   
7. //合并两个链表  
8. ListNode* MergeList(ListNode *headOne, ListNode *headTwo){  
9.     //如果第一个链表是空链表返回链表2头结点   
10.     if(headOne == NULL){  
11.        return headTwo;  
12.     }  
13.     //如果第二个链表是空链表返回链表1头结点   
14.     if(headTwo == NULL){  
15.        return headOne;   
16.     }  
17.     //设定两个指针分别指向两个链表头结点   
18.     ListNode *p1 = headOne;  
19.     ListNode *p2 = headTwo;  
20.     ListNode *newHeadNode = NULL;  
21.     //判断哪一个是新的头结点  
22.     if((p1->value) <= (p2->value)){  
23.        newHeadNode = p1;  
24.        p1 = p1->nextNode;  
25.     }   
26.     else{  
27.        newHeadNode = p2;  
28.        p2 = p2->nextNode;       
29.     }  
30.     //设置一个指向新链表的指针   
31.     ListNode *curNode = newHeadNode;  
32.     //合并两个链表  
33.     while((p1 != NULL) && (p2 != NULL)){  
34.        if((p1->value) <= (p2->value)){  
35.            curNode->nextNode = p1;  
36.            curNode = curNode->nextNode;  
37.            p1 = p1->nextNode;  
38.        }  
39.        else{  
40.            curNode->nextNode = p2;  
41.            curNode = curNode->nextNode;  
42.            p2 = p2->nextNode;          
43.        }  
44.     }   
45.     //把剩下没有加入的全部加入新链表  
46.     //最多只会有一个链表不为空   
47.     while((p1 != NULL)){  
48.        curNode->nextNode = p1;  
49.        curNode = curNode->nextNode;  
50.        p1 = p1->nextNode;   
51.     }   
52.     while(p2 != NULL){  
53.        curNode->nextNode = p2;  
54.        curNode = curNode->nextNode;  
55.        p2 = p2->nextNode;  
56.     }  
57.     //返回新的链表结点   
58.     return newHeadNode;  
59. }   

递归代码，更加简洁

[cpp] view plaincopy

1. struct ListNode{  
2.     int value;  
3.     ListNode *nextNode;  
4. };   
5.   
6. //合并两个链表  
7. ListNode* MergeList(ListNode *headOne, ListNode *headTwo){  
8.     //链表1为空   
9.     if(headOne == NULL){  
10.         return headTwo;  
11.     }  
12.     //链表2为空   
13.     if(headTwo == NULL){  
14.         return headOne;   
15.     }  
16.     //新建一个结点  
17.     ListNode *newNode = NULL;  
18.     if((headOne->value) <= (headTwo->value)){  
19.         newNode = headOne;  
20.         newNode->nextNode = MergeList(headOne->nextNode, headTwo);  
21.     }   
22.     else{  
23.         newNode = headTwo;  
24.         newNode->nextNode = MergeList(headOne, headTwo->nextNode);  
25.     }  
26.     return newNode;  
27. }