输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

剑指offer：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：首先确定输出链表的头result为输入两个链表头中较小的一个。然后不断比较，把输入连个链表中头较小的依次插入输出链表尾部。所以需要一个结点指针end指向输出链表的尾结点。

//#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <stack>
#include <math.h>
#include <iostream>
using namespace std;
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
class Solution {
public:
ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
{
ListNode* result,*end;//result为输出链表头，end为输出链表尾。
if(pHead1 == NULL)
return pHead2;
if(pHead2 == NULL)
return pHead1;

if(pHead1 != NULL && pHead2 != NULL)//确定输出头
if(pHead1->val <= pHead2->val){
result = pHead1;
pHead1 = pHead1->next;
}
else{
result = pHead2;
pHead2 = pHead2->next;
}
end = result;//此时头和尾相同

while(pHead1 != NULL && pHead2 != NULL){//不断比较插入尾部，直到一个输入链表为空
if(pHead1->val <= pHead2->val){
end->next = pHead1;//插入尾部
end = end->next;//更新尾部
pHead1 = pHead1->next;//跟新输入链表1的头
}
else{
end->next = pHead2;
end = end->next;
pHead2
4000
= pHead2->next;
}
}

if(pHead1 == NULL)//一个输入链表为空后，直接将另外一个插入输出的尾部，end 不用跟新了
end->next = pHead2;
else
end->next = pHead1;
return result;
}
};

int main()
{
struct ListNode* p1 = (struct ListNode*)malloc(sizeof(struct ListNode));
//struct ListNode* p2 = (struct ListNode*)malloc(sizeof(struct ListNode));
ListNode* p2 = new ListNode(1);

struct ListNode* r = (struct ListNode*)malloc(sizeof(struct ListNode));
p1->val = 0;
p1->next = NULL;

for(int i = 6; i >= 2; i -= 2){
struct ListNode* t = (struct ListNode*)malloc(sizeof(struct ListNode));
t->val = i;
t->next = p1->next;
p1->next = t;
}
for(int i = 7; i > 1; i -= 2){
struct ListNode* t = (struct ListNode*)malloc(sizeof(struct ListNode));
t->val = i;
t->next = p2->next;
p2->next = t;
}
Solution s;
r = s.Merge(p1,p2);
while(r != NULL){
cout << r->val << endl;
r = r->next;
}

system("pause");
return 0;
}