合并K组链表以及合并两个链表（递归快速排序）

合并K组链表
思路：刚开始打算两两合并，时间复杂度太高为n*合并两个链表的复杂度
会超出时间限制
于是暴力提取链表 n+nlgn+n 快排，创建链表
8ms超过100%的用户
代码段如下

//思路2
void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

void quick_sort_recursive(int arr[], int start, int end) {
    if (start >= end)
        return;
    int mid = arr[end];
    int left = start, right = end - 1;
    while (left < right) {
        while (arr[left] < mid && left < right)
            left++;
        while (arr[right] >= mid && left < right)
            right--;
        swap(&arr[left], &arr[right]);
    }
    if (arr[left] >= arr[end])
        swap(&arr[left], &arr[end]);
    else
        left++;
    if (left)
        quick_sort_recursive(arr, start, left - 1);
        quick_sort_recursive(arr, left + 1, end);
}

struct ListNode* mergeKLists(struct ListNode** lists, int listSize)
{
        //遍历链表取出数
        int num[6000];
        int i=0;
        int j=0;
        int k=0;
        //各个头结点统计处理
        ListNode *head=NULL;
        ListNode *result=NULL;
        ListNode *s;
        ListNode node;
        printf("this is me \n");
//        printf("listSize is %d\n",listSize);
//        printf("i is %d\n",i);
        for(i;i<listSize;i++)
        {
            head=*(lists+i);
            while(head!=NULL)
            {
               node.val=head->val;
               num[j]=node.val;
               head=head->next;
               j++;
            }
        }
//        for(k;k<j;k++)
//        {
//            printf("num[%d] is %d\n",k,num[k]);
//        }
//      j就是size
        if(j==0){return NULL;}
        quick_sort_recursive(num,0,j-1);
        //从小到大已经排序好创建链表
        result=creTailList(num,j);
        return result;
}
//这是思路1
struct ListNode* mergeKListsOne(struct ListNode** lists, int listSize){
    //递归调用
    ListNode* head=NULL;
    int size=listSize;
    int j=0;
    while(j!=listSize)
    {
        printf("J is %d\n",j);
        head=mergeTwoLists(head,*(lists+j));
        j++;
    }
    return head;
    }
    
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {

    ListNode *head;
    ListNode *tail;
    ListNode *s;
    ListNode node;
    head=NULL;
    if(l1==NULL){return l2;}
    if(l2==NULL){return l1;}
    if(l1==NULL&&l2==NULL){
        return NULL;
    }
    //尾插法建立链表
    while(l1!=NULL&&l2!=NULL)
    {
        //比较取小的，并且创建新链表
        s=(ListNode *)malloc(sizeof(ListNode));
        if(l1->val<=l2->val)
           {
            if(head==NULL)
                {
                    node.val=l1->val;
                    s->val=node.val;
                    head=s;
                    tail=s;
                    l1=l1->next;
                }
                else
                {
                    node.val=l1->val;
                    s->val=node.val;
                    s->next=NULL;
                    tail->next=s;
                    tail=s;
                    l1=l1->next;
                }
           }
           else{
               if(head==NULL)
                {
                    node.val=l2->val;
                    s->val=node.val;
                    head=s;
                    tail=s;
                    l2=l2->next;
                }
                else
                {
                    node.val=l2->val;
                    s->val=node.val;
                    s->next=NULL;
                    tail->next=s;
                    tail=s;
                    l2=l2->next;
                }
           }
    }
    while(l1!=NULL)
        {
            s=(ListNode *)malloc(sizeof(ListNode));
            node.val=l1->val;
            s->val=node.val;
            s->next=NULL;
            tail->next=s;
            tail=s;
            l1=l1->next;
        }
            while(l2!=NULL)
        {
            s=(ListNode *)malloc(sizeof(ListNode));
            node.val=l2->val;
            s->val=node.val;
            s->next=NULL;
            tail->next=s;
            tail=s;
            l2=l2->next;
        }
        tail->next=NULL;
        return head;
}