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[] = {{.next=NULL,.val=}, {.next=NULL, .val=-}};
     ListNodePointer pListPointerArray[] = {&list[], NULL, &list[]};

     ListNodePointer header = mergeKLists(pListPointerArray, );

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

     return ;
 }

 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(  );
 }

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

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

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

     ListNodePointer pMinNode = lists[];

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

     MinHeapify(lists, *pListSize, );

     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 >  && 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 = ;

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

     if ( nHeapSize ==  )
     {
         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 !=  )
     {
         pTail->next = ExtractMin(pListPointerArray, &nHeapSize);

         pTail = pTail->next;

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

     free(pListPointerArray);

     return header.next;
 }