LeetCode —— Merge k Sorted Lists

/*
** 算法的思路：
**  1.将k个链表的首元素进行建堆
**  2.从堆中取出最小的元素，放到链表中
**  3.如果取出元素的有后续的元素，则放入堆中，若没有则转步骤2，直到堆为空
*/


#include <stdio.h>


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


#define PARENT(i) (((i)-1)/2)
#define LEFT(i)    ((i)*2+1)
#define RIGHT(i)    ((i)*2+2)

typedef struct ListNode * ListNodePointer;


void MinHeapify(ListNodePointer lists[], int nListSize, int nParentIndex );
void BuildMinHeap(ListNodePointer lists[], int nListSize );
ListNodePointer ExtractMin( ListNodePointer lists[], int *pListSize );
void InsertHeap(ListNodePointer lists[], int *pListSize, ListNodePointer pNode );
struct ListNode* mergeKLists(struct ListNode** lists, int listsSize);



int main(int argc, char const *argv[])
{
    
    struct ListNode list[2] = {{.next=NULL,.val=2}, {.next=NULL, .val=-1}};
    ListNodePointer pListPointerArray[3] = {&list[0], NULL, &list[1]};

    ListNodePointer header = mergeKLists(pListPointerArray, 3);

    ListNodePointer pList = header;
    while( NULL != pList )
    {
        printf("%d ", pList->val);
        pList = pList->next;
    }
    printf("
");

    return 0;
}



void MinHeapify(ListNodePointer lists[], int nListSize, int nParentIndex )
{

    int nLeftIndex;        //左节点下标
    int nRightIndex;    //右节点下标
    int nMinIndex;        //最小节点下标
    ListNodePointer pNodePtrTmp;

    do
    {
        nLeftIndex = LEFT(nParentIndex);
        nRightIndex = RIGHT(nParentIndex);
        nMinIndex = nParentIndex;

        if ( nLeftIndex < nListSize && lists[nLeftIndex]->val < lists[nMinIndex]->val )
        {
            nMinIndex = nLeftIndex;
        }

        if ( nRightIndex < nListSize && lists[nRightIndex]->val < lists[nMinIndex]->val )
        {
            nMinIndex = nRightIndex;
        }

        if ( nMinIndex != nParentIndex )
        {
            pNodePtrTmp = lists[nMinIndex];
            lists[nMinIndex] = lists[nParentIndex];
            lists[nParentIndex] = pNodePtrTmp;

            nParentIndex = nMinIndex;

        }else
        {
            break;
        }

    }while( 1 );
}

//建堆
void BuildMinHeap(ListNodePointer lists[], int nListSize )
{

    int i;
    for ( i = nListSize/2; i >= 0; i-- )
    {
        MinHeapify(lists, nListSize, i);
    }
}

//从堆中取出最小的元素
ListNodePointer ExtractMin( ListNodePointer lists[], int *pListSize )
{

    ListNodePointer pMinNode = lists[0];

    (*pListSize)--;
    lists[0] = lists[*pListSize];

    MinHeapify(lists, *pListSize, 0);

    return pMinNode;
}

//向堆中添加元素
void InsertHeap(ListNodePointer lists[], int *pListSize, ListNodePointer pNode )
{

    int nCurNodeIndex = *pListSize;
    int nParentIndex = PARENT(nCurNodeIndex);
    ListNodePointer pNodePtrTmp;

    lists[nCurNodeIndex] = pNode;
    (*pListSize)++;

    while ( nCurNodeIndex > 0 && lists[nParentIndex]->val > lists[nCurNodeIndex]->val )
    {
        pNodePtrTmp = lists[nParentIndex];
        lists[nParentIndex] = lists[nCurNodeIndex];
        lists[nCurNodeIndex] = pNodePtrTmp;

        nCurNodeIndex = nParentIndex;
        nParentIndex = PARENT(nCurNodeIndex);
    }
}


struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) 
{
    

    ListNodePointer *pListPointerArray = (ListNodePointer *) malloc( sizeof(ListNodePointer)*listsSize );
    struct ListNode header = {.next=NULL};
    ListNodePointer pTail = NULL;

    int i;
    int nHeapSize = 0;

    for( i=0; i<listsSize; i++ )
    {
        if ( lists[i] != NULL )
        {
            pListPointerArray[nHeapSize] = lists[i];
            nHeapSize++;
        }
    }

    if ( nHeapSize == 0 )
    {
        return NULL;
    }

    BuildMinHeap(pListPointerArray, nHeapSize);

    //这里为预处理
    header.next = ExtractMin(pListPointerArray, &nHeapSize);
    pTail = header.next;
    if ( NULL != pTail && pTail->next != NULL )
    {
        InsertHeap(pListPointerArray, &nHeapSize, pTail->next );
    }

    while( nHeapSize != 0 )
    {
        pTail->next = ExtractMin(pListPointerArray, &nHeapSize);

        pTail = pTail->next;

        if ( NULL != pTail && NULL != pTail->next )
        {
            InsertHeap(pListPointerArray, &nHeapSize, pTail->next );
        }
    }

    free(pListPointerArray);

    return header.next;
}