leecode-C语言实现-23. 合并K个升序链表

一、题目


二、解题思路
根据提示我们知道数值的最小值为-10000，最大值为10000，实际测试leecode需要的最小值为-5000，最大值为5000，那我们可以初始化一个数组长度10001，多的1是因为要算上0，数据组中的值都初始化为0，在定义一个变量来记录最小值-5000，形成一个key对value的形式，避免了插入排序。

再将每个链表中的值以计数的方式记录到数组中，
例如链表为：1》4》5
例如数组起始为：{0，0，0，0，0，0，0，0，0，0}
例如对应key 为 ：{0，1，2，3，4，5，6，7，8，9}
数组太大，我们这里为了方便只显示一部分，并不代表数组就这么长。
key并不是数组只是单单一个变量，这里这么表示只是方便理解。

（1）节点值为1
例如数组后续为 ：{0，1，0，0，0，0，0，0，0，0}
例如对应 key 为 ：{0，1，2，3，4，5，6，7，8，9}

（2）节点值为4
例如数组后续为 ：{0，1，0，0，1，0，0，0，0，0}
例如对应 key 为 ：{0，1，2，3，4，5，6，7，8，9}

（2）节点值为5
例如数组后续为 ：{0，1，0，0，1，1，0，0，0，0}
例如对应 key 为 ：{0，1，2，3，4，5，6，7，8，9}

最后再将数组中的值依次遍历到新的链表中即可。

三、VS-2017-测试代码

#include 
#include 
#include 
#define TPASIZE 3

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize);
int ListData2ArrData(struct ListNode* head, int KeyNum, int* ValArr, int ArrSize);
void ArrData2ListData(struct ListNode* head, int KeyNum, int* ValArr, int ArrSize, int cnt);

struct ListNode* BuildList(int arr[], int arrsize);
void PrintfList(struct ListNode* head);
void PrintfArr(void *arr, int size, int elementsize);

void main()
{
    struct ListNode* TestPointArr[TPASIZE];
    int IntArr[TPASIZE][TPASIZE] = { {1,4,5},{1,3,4},{2,6} };
    int i;

    for ( i = 0; i < TPASIZE; i++)
    {
        TestPointArr[i] = BuildList(IntArr[i], TPASIZE);
        PrintfList(TestPointArr[i]);
    }
    struct ListNode* res = mergeKLists(TestPointArr, TPASIZE);
    PrintfList(res);
}

struct ListNode* BuildList(int arr[], int arrsize)
{
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* p = head;
    int i;
    int tmp = arr[0];

    head->val = arr[0];
    head->next = NULL;

    //printf("arr[i] : %d, tmp : %d\n", arr[0], tmp);

    for ( i = 1; i < arrsize; i++)
    {
        if (tmp <= arr[i])
        {
            //printf("arr[i] : %d, tmp : %d\n", arr[i],tmp);
            struct ListNode* q = (struct ListNode*)malloc(sizeof(struct ListNode));
            tmp = arr[i];
            q->val = arr[i];
            q->next = NULL;
            p->next = q;
            p = q;
        }
        else
        {
            break;
        }
    }
    return head;
}

void PrintfList(struct ListNode* head) {
    struct ListNode* p = head;
    while (p != NULL) {
        printf("cur_p : %p, val : %d, next : %p\n", p, p->val, p->next);
        p = p->next;
    }
    printf("+++++++++++++++++++++\n");
}

void PrintfArr(void *arr, int size, int elementsize)
{
    if (elementsize == sizeof(int))
    {
        int *tmparr = (int*)arr;
        int i;
        for (i = 0; i < size; i++)
        {
            printf("%d ", tmparr[i]);
        }
    }
    else if (elementsize == sizeof(char))
    {
        char *tmparr = (char*)arr;
        int i;
        for (i = 0; i < size; i++)
        {
            printf("%c ", tmparr[i]);
        }
    }
    printf("\n========================\n");
}

/*
1、初始化一个长度为20001的数组，赋值-10000到10000。
2、初始化一个长度为20001的数组，初始化为0，里面记录数值出现的次数。
3、遍历所有链表，把值记录到数组中。
4、遍历数组，数组中的值取出，放到链表中。
*/

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize)
{
    if (listsSize == 0)
    {
        return NULL;
    }
    //int ArrSize = 20001;
    int ArrSize = 10001;
    int KeyNum = (ArrSize - 1) / (-2);
    int* ValArr = (int*)malloc(sizeof(int) * ArrSize);
    struct ListNode* res = (struct ListNode*)malloc(sizeof(struct ListNode));
    int i;
    int cnt = 0;

    res->val = 0;
    res->next = NULL;

    //初始化一个长度为20001的数组，赋值-10000到10000。
    //初始化一个长度为20001的数组，初始化为0，里面记录数值出现的次数。
    //实际测试只需要长度为10001的数组。
    //for ( i = 0; i < ArrSize; i++)
    //{
    //    //KeyArr[i] = -10000 + i;
    //    ValArr[i] = 0;
    //}

    //一般如 char、int、float、double 等类型的变量memset直接初始化即可
    //整型数组初始化，第三个参数需要乘上int在内存中的长度
    memset(ValArr,0, ArrSize * sizeof(int));
    

    //遍历所有链表，把值记录到数组中。
    for ( i = 0; i < listsSize; i++)
    {
        cnt += ListData2ArrData(lists[i], KeyNum, ValArr, ArrSize);
    }
    //PrintfArr(ValArr, ArrSize, sizeof(int));
    
    //遍历数组，数组中的值取出，放到链表中。
    ArrData2ListData(res, KeyNum, ValArr, ArrSize, cnt);

    return res->next;
}

int ListData2ArrData(struct ListNode* head, int KeyNum, int* ValArr, int ArrSize)
{
    struct ListNode* p = head;
    int i;
    int cnt = 0;
    int tmp = 0;//由于是个递增链表，所以添加此变量，使每次循环i不从0开始。

    while (p != NULL)
    {
        for ( i = tmp; i < ArrSize; i++)
        {
            if (p->val == KeyNum)
            {
                ValArr[i]++;
                tmp = i;
                cnt++;
                break;
            }
            KeyNum++;
        }
        p = p->next;
    }
    return cnt;
}

void ArrData2ListData(struct ListNode* head, int KeyNum, int* ValArr, int ArrSize, int cnt)
{ 
    struct ListNode* p = head;
    int i,j;
    int tmp_cnt = 0;//判断是否到元素的最后一位，可以减少多余的数组遍历。

    for ( i = 0; i < ArrSize; i++)
    {
        if (ValArr[i] != 0)
        {
            for ( j = 0; j < ValArr[i]; j++)
            {
                struct ListNode* q = (struct ListNode*)malloc(sizeof(struct ListNode));
                q->val = KeyNum;
                q->next = NULL;
                p->next = q;
                p = q;
                tmp_cnt++;
            }
            if (tmp_cnt == cnt)
            {
                printf("cnt : %d\n",cnt);
                break;
            }
        }
        KeyNum++;
    }
}

四、VS-2017代码测试截图

五、leecode提交代码

int ListData2ArrData(struct ListNode* head, int KeyNum, int* ValArr, int ArrSize)
{
    struct ListNode* p = head;
    int i;
    int cnt = 0;
    int tmp = 0;
    while (p != NULL)
    {
        for ( i = tmp; i < ArrSize; i++)
        {
            if (p->val == KeyNum)
            {
                ValArr[i]++;
                tmp = i;
                cnt++;
                break;
            }
            KeyNum++;
        }
        p = p->next;
    }
    return cnt;
}

void ArrData2ListData(struct ListNode* head, int KeyNum, int* ValArr, int ArrSize, int cnt)
{ 
    struct ListNode* p = head;
    int i,j;
    int tmp_cnt = 0;
    for ( i = 0; i < ArrSize; i++)
    {
        if (ValArr[i] != 0)
        {
            for ( j = 0; j < ValArr[i]; j++)
            {
                struct ListNode* q = (struct ListNode*)malloc(sizeof(struct ListNode));
                q->val = KeyNum;
                q->next = NULL;
                p->next = q;
                p = q;
                tmp_cnt++;
            }
            if (tmp_cnt == cnt)
            {
                break;
            }
        }
        KeyNum++;
    }
}

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize)
{
    if (listsSize == 0)
    {
        return NULL;
    }
    int ArrSize = 10001;
    int KeyNum = (ArrSize - 1) / (-2);
    int* ValArr = (int*)malloc(sizeof(int) * ArrSize);
    struct ListNode* res = (struct ListNode*)malloc(sizeof(struct ListNode));
    int i;
    int cnt = 0;
    res->val = 0;
    res->next = NULL;
    memset(ValArr,0, ArrSize * sizeof(int));
    for ( i = 0; i < listsSize; i++)
    {
        cnt += ListData2ArrData(lists[i], KeyNum, ValArr, ArrSize);
    }
    ArrData2ListData(res, KeyNum, ValArr, ArrSize,cnt);
    return res->next;
}

六、leecode提交截图