【21天考研算法带刷leetcode-25】合并链表的几种方法（10/21）

时间即将过半啦 继续加油哇    !!!!!!

合并链表下文介绍了几种方法,包括介绍了直接插入法  不建立新链表的直接插入法  以及更简洁的递归解法

一、合并两个有序链表．

较为简单的方法,新建一个头结点,每次选最小的进行尾插法.

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
        struct ListNode* preHead = (struct ListNode*)malloc(sizeof(struct ListNode));
        struct ListNode* prev = preHead;
        while (l1 != NULL && l2 != NULL) {
            if (l1->val < l2->val) {
                prev->next = l1;
                l1 = l1->next;
            } else {
                prev->next = l2;
                l2 = l2->next;
            }
            prev = prev->next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev->next = l1 == NULL ? l2 : l1;

        return preHead->next;
}

如果题目要求,仅仅在原有的链表上完成操作,直接插入排序(不使用新的头结点,而是利用原来的头结点),本质上实现的是选择把l2中的结点放到他该放的位置上,但这种方法对l2要插入到l1前面的位置需要单独判断,那么如果在前面强制把l2变成开头较小的那一条就不会出问题了.

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    if(l1==NULL ) return l2;
    if(l2==NULL ||l1->val > l2->val ) return mergeTwoLists;
    struct ListNode* p=l1;
    while(p&&l2){
        if((p->next!=NULL&&p->next->val>l2->val && l2->val>=p->val)||(p->next==NULL&&l2->val>=p->val)){
            struct ListNode* temp=l2->next;
            l2->next=p->next;
            p->next=l2;
            l2=temp;
            p=p->next;
        }
        else p=p->next;
        

    }
    if(p==NULL&&l2!=NULL){
            p=l2;
    }
    return l1;
}

第二种方法 递归 超级简洁 每次选一个最小的然后将剩下的做递归 return l1

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
  if(l1==NULL) return l2;
  else if(l2==NULL) return l1;
  else if(l1->val<=l2->val) {l1->next=mergeTwoLists(l1->next,l2); return l1;}
  else l2->next=mergeTwoLists(l1,l2->next); return l2;
}

二、合并k个升序链表

待补充

首先我们需要一个变量 \textit{head}head 来保存合并之后链表的头部，你可以把 \textit{head}head 设置为一个虚拟的头（也就是 \textit{head}head 的 \textit{val}val 属性不保存任何值），这是为了方便代码的书写，在整个链表合并完之后，返回它的下一位置即可。

每次从链表集合中 getlist选一个最小的取出,以及locate,然后插入到新链表中.

struct ListNode* get_min(struct ListNode** list,int n){
    int min=0x7fffffff;
    int locate=-1;
    for(int i=0;i<n;i++){
        if(list[i]!=NULL&&list[i]->val <min){
        min=list[i]->val;
        locate=i;
        }
    }
    return locate;
}
struct ListNode* mergeKLists(struct ListNode** lists, int listsSize){
    if(listsSize==0) return NULL;
    int record=get_min(lists,listsSize);
    struct ListNode* L=(struct ListNode*)malloc(sizeof(struct ListNode));
    L->next=NULL;
    while(record!=-1&&lists[record]!=NULL){
        int key=lists[record]->val;
        struct ListNode* p=L;
        while(p->next!=NULL && key>p->next->val){
            p=p->next;
        }
        struct ListNode* temp=lists[record]->next;
        lists[record]->next=p->next;
        p->next=lists[record];
        lists[record]=temp;
        record=get_min(lists,listsSize);
    }
    return L->next;
}