试了三种方法

第一种：先把所有链表首尾相接，之后再利用冒泡排序。

    struct ListNode p1;
    struct ListNode p2;
    struct ListNode p3;
    struct ListNode phead;
    p0=NULL;
    p1=NULL;
    int n=0;
    将k个链表合并到一起
    if(listsLen==1)
    {
        return lists[0];
    }

    for(int i=0;i(listsLen-1);i++)
    {
        if(lists[i]!=NULL)
        {
            p0 = lists[i];
        }
        p1 = lists[i+1];
        
        if(p1!=NULL && p0!=NULL)
        {
            while(p0-next!=NULL)
            {
                p0 = p0-next;
            }
            p0-next = p1;
        }
    
    }
    phead = lists[0];
    将链表中的元素排序，采用冒泡法
    p0 = phead;
    if(p0==NULL  p0-next==NULL)
    {
        return p0;
    }
    while(p0-next!=NULL)
    {
        p0 = p0-next;
        n++;
    }
    p0 = phead;
    for(int i=0;in;i++)
    {
        p0 = phead;
        p1 = p0;    
        for(int j=0;j(n-i);j++)
        {
            p2 = p1-next;
            p3 = p2-next;
            if(p2-val  p1-val)
            {
                p2-next = p1;
                p1-next = p3;
                if(p1==phead)
                {

                    phead = p2;
                }
                else
                {
                    p0-next = p2;
                }
                p0 = p2;
            }
            else
            {
                p0 = p1;
            }
            p1 = p0-next;
        }
    }
    return phead;

第二种：插入排序法，第一个链表和第二个链表，通过比较元素的大小完成合并，将这个大链表作为第一个，再往后寻找第二个链表，再进行合并，采取两两合并。

    struct ListNode* p1;
    struct ListNode* p2;
    struct ListNode* p3;
    struct ListNode* p4;
    
    if(listsLen==0 || listsLen==1)
    {
        return lists[0];
    }
    p0 = lists[0];
    p1 = NULL;
    
    for(int i=0;i<(listsLen-1);i++)
    {
        if(p0 == NULL)
        {
            p0 = lists[i];
        }
        p1 = lists[i+1];
        if(p0!=NULL && p1!=NULL)
        {
            if(p0->val > p1->val)
            {
                p2 =p0;
                p0 = p1;
                p1 = p2;
            }
            p2 = p0;
            p3 = p1;
            p4 = p2;
            while(p2!=NULL && p3!=NULL)
            {
                if(p3->val < p2->val)
                {
                    p1 = p1->next;
                    p4->next = p3;
                    p3->next = p2;
                    p4 = p3;
                    p3 = p1;
                }
                else
                {
                    p4 = p2;
                    p2 = p2->next;
                }
            }
            if(p4->next==NULL)
            {
                 p4->next = p1;
            }
        }
    }
    return p0;

第三种：粗暴方法，将所有元素都提出来存到数组里，升序排列后，再生成新的链表

 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */

/**
 * 
 * @param lists ListNode类一维数组 
 * @param listsLen int lists数组长度
 * @return ListNode类
 */
int cmp ( const void *a , const void *b )   
{   
    return *(int *)a - *(int *)b;  
}
struct ListNode* mergeKLists(struct ListNode** lists, int listsLen ) {
    // write code here
    struct ListNode* result = malloc(sizeof(struct ListNode));
    int list[100000];
    int j=0;
    struct ListNode* p0;
    for(int i=0;i<listsLen;i++)
    {
        p0 = lists[i];
        while(p0!=NULL)
        {
            list[j++]=p0->val;
            p0 = p0->next;
        }
        
    }
    qsort(list, j, sizeof(int), cmp);
    p0 = result;
    for(int i=0;i<j;i++)
    {
        struct ListNode* temp = malloc(sizeof(struct ListNode));
        temp->val = list[i];
        temp->next = NULL;
        p0->next = temp;
        p0 = p0->next;
    }
    return result->next;
    
}