把两个从大到小的有序链表合并成一个链表，新的链表是一个从小到大的有序链表

实现一个函数，把两个从大到小的有序链表合并成一个链表，新的链表是一个从小到大的有序链表。

可以分成两个思路：

1.先把两个链表合并成一个链表，合并后的链表从大到小排序

2.将链表逆置，得到从小到达排序的链表

链表合并

最粗暴的方法，遍历第一个链表的节点，和第二个链表的每一个节点比较，找出最小者作为链表的新节点插入，这个方法的时间复杂度为O(len1*len2)。

由于两个链表是有序的，因此我们可以分别从两个链表的第一个节点开始比较，把用于指向新链表的指针指向头节点值比较大的链表，记这个链表为list1。然后指向list1的第二个节点，而lsit2则不动，仍然指向头节点，list1的第二个节点继续比较，取较大者为新的节点。

如果两个链表不等长，那么必有一个链表先遍历完，只需要把还没有遍历完的链表剩下的部分加入到新的链表即可。

用这种方式，就可以在O(len1+len2)完成任务，且不需要再构造新的存储空间。

List_t *pNew = NULL;
List_t *pCur = NULL;

if(h1 == NULL || h2 == NULL){//如果其中一个链表为空，则不需要比较，返回
return NULL;
}

//找出头结点较大的链表，把新链表的指针指向它
if(h1->data >= h2->data){
pNew = h1;
h1 = h1->next;
}
else{
pNew = h2;
h2 = h2->next;
}
pCur = pNew;

do{
//取节点较大值作为新链表的节点
if(h1->data >= h2->data){
pCur->next = h1;
pCur = pCur->next;
h1 = h1->next;
}
else{
pCur->next = h2;
pCur = pCur->next;
h2 = h2->next;
}

}while(h1 != NULL && h2 != NULL);//用do-while，因为第一次h1和h2肯定不为空，否则前面已经返回

List_t *cnt;
if(h1 == NULL && h2 == NULL){//两个链表一样长，新的链表已经组合完成，返回
return pNew;
}
pCur->next = h1?h1:h2;//必有一个为空，直接把不为空的剩余部分链到新链表后面

链表逆置

得到新的链表后，要把链表进行逆置，一开始可能会想到构造一个新的链表，将原链表遍历一遍，然后将节点一个个复制下来。

其实只要用两个指针指向相邻的两个节点，然后把指向逆转（next指针），当然在此之前要保存好后一个节点原来的next指针（第三个节点），否则就失去这个链表的踪迹了。

List_t *p2 = pNew->next;
pNew->next = NULL;//原头节点变为尾节点，指向NULL
List_t *tmp;

while(p2 != NULL){
tmp = p2->next; //保存第三个节点的地址
p2->next = pNew;//逆转指向
pNew = p2;//指针后移，原先指向第一个节点，现在指向第二个节点
p2 = tmp;//指针后移，原先指向第二个节点，现在指向第三个节点
}

至此，就完成了链表合并以及逆置，完整代码如下：

#include <string.h>
#include <malloc.h>
#include <iostream>
#include <vector>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

typedef struct mList{
int data;
struct mList *next;
}List_t;

void PrintData(List_t* L){
List_t* tmp = L;
while(tmp != NULL){
cout << tmp->data << " ";
tmp = tmp->next;
}
cout << endl;
}

List_t* mergeList(List_t* h1, List_t* h2){
List_t *pNew = NULL;
List_t *pCur = NULL;

if(h1 == NULL || h2 == NULL){//如果其中一个链表为空，则不需要比较，返回
return NULL;
}

//找出头结点较大的链表，把新链表的指针指向它
if(h1->data >= h2->data){
pNew = h1;
h1 = h1->next;
}
else{
pNew = h2;
h2 = h2->next;
}
pCur = pNew;

do{
//取节点较大值作为新链表的节点
if(h1->data >= h2->data){
pCur->next = h1;
pCur = pCur->next;
h1 = h1->next;
}
else{
pCur->next = h2;
pCur = pCur->next;
h2 = h2->next;
}

}while(h1 != NULL && h2 != NULL);//用do-while，因为第一次h1和h2肯定不为空，否则前面已经返回

List_t *cnt;
if(h1 == NULL && h2 == NULL){//两个链表一样长，新的链表已经组合完成，返回
return pNew;
}
pCur->next = h1?h1:h2;//必有一个为空，直接把不为空的剩余部分链到新链表后面

PrintData(pNew);

List_t *p2 = pNew->next;
pNew->next = NULL;//原头节点变为尾节点，指向NULL
List_t *tmp;

while(p2 != NULL){
tmp = p2->next; //保存第三个节点的地址
p2->next = pNew;//逆转指向
pNew = p2;//指针后移，原先指向第一个节点，现在指向第二个节点
p2 = tmp;//指针后移，原先指向第二个节点，现在指向第三个节点
}

PrintData(pNew);

return pNew;
}

int main(){
int data1[] = {100, 77, 52, 23, 10, 4, 0};
int data2[] = {83, 80, 26, 15, 3, 2, 1, 0};

int l1 = sizeof(data1)/sizeof(data1[0]);
List_t *q = NULL;
List_t *h1 = NULL;
for(int idx = 0; idx < l1; idx++){
List_t *p = (List_t*)malloc(sizeof(List_t));
p->data = data1[idx];
p->next = NULL;

if(h1 == NULL){
h1 = p;
}
else{
q->next = p;
}
q = p;
}

int l2 = sizeof(data2)/sizeof(data2[0]);
q = NULL;
List_t *h2 = NULL;
for(int idx = 0; idx < l2; idx++){
List_t *p = (List_t*)malloc(sizeof(List_t));
p->data = data2[idx];
p->next = NULL;

if(h2 == NULL){
h2 = p;
}
else{
q->next = p;
}
q = p;
}

mergeList(h1,h2);
}

对两个序列：

100, 77, 52, 23, 10, 4, 0

83, 80, 26, 15, 3, 2, 1, 0

操作后的结果：