!Leetcode

字节跳动的面试算法题：合并K个有序的元素个数为N的数组

思想将数组的首元素建立一个大根堆，然后进行堆调整，代码有注释

//
// Created by yanpan on 2019/3/26.
//  字节跳动的手写算法题 2019春招
#if 0
#include <iostream>
#include <vector>
#include <algorithm>
#include <time.h>
using namespace std;

#define n 5

typedef struct MaxheapNode
{
    int element;  //节点的元素
    int i;        //数组的索引
    int j;        //数组元素的索引
}MaxheapNode;


//进行堆调整   //时间复杂度为 o(log n)
void MaxHeap_Adjust(MaxheapNode *arr, int start, int len)
{
    int temp;
    int left;
    while((left = start * 2 + 1) <= len)  //判断当前节点有无孩子节点
    {
        int right = left + 1;
        int j = left;
        if (right <= len && arr[right].element >= arr[left].element)  //如果有右孩子找到最大的孩子节点
        {
            ++j;        //如果右孩子最大则对j加一，下标挪到最大的孩子节点
        }
        //判断父节点是否大于子节点中最大的节点，如果小于将与最大的孩子节点进行值交换
        if (arr[j].element > arr[start].element)
        {
            temp = arr[start].element;
            int i = arr[start].i;
            int h = arr[start].j;
            arr[start].element = arr[j].element;
            arr[start].i = arr[j].i;
            arr[start].j = arr[j].j;
            arr[j].element = temp;
            arr[j].i = i;
            arr[j].j = h;
        }
            //如果父节点大于孩子节点则退出循环
        else
            break;
        //调整完成后将 孩子节点的下标赋值给 start，继续判断调整过后的子节点是否是大于它的孩子节点
        start = j;
    }
}


void show(vector<int> vec);

void Sort(int k, int arr[][n])
{
    vector<int> vec;
    MaxheapNode * brr = (MaxheapNode*) malloc ((k+1) * sizeof(MaxheapNode));
    for(int i = 0; i <= k; i++)
    {
        brr[i].element = arr[i][0];
        brr[i].i = i;
        brr[i].j = 0;
    }
    //建立大根堆  时间复杂度为o(n)
    for(int start = (k - 1) / 2; start >= 0; start--)
        MaxHeap_Adjust(brr,start,k);

    //取出最大的数字，并进行堆调整   时间复杂度为o(n)
    //取出最大的元素后将该元素所在数组的下一个元素放进堆顶进行堆tiaozheng
    //如果一个数组的元素都取完了，将堆的大小减一
    int num = n*(k+1);
    for(int count = 0; count < num; count++)
    {
        int i = brr[0].i;        //该元素对应的数组的索引
        int j = brr[0].j + 1;    //该元素的下标加一
        vec.push_back(brr[0].element);  //将堆顶的值入vector中
        if(j < n)                //该元素所在数组没有空
        {
            brr[0].element = arr[i][j];
            brr[0].i = i;
            brr[0].j = j;
        }
        else                      //将堆的长度减一
        {
            brr[0].element = brr[k].element;
            brr[0].i = brr[k].i;
            brr[0].j = brr[k].j;
            k--;
        }
        MaxHeap_Adjust(brr, 0, k);
    }
    show(vec);
    free(brr);
}

void show(vector<int> vec)
{
    vector<int>::iterator it = vec.begin();
    while(it != vec.end())
    {
        cout<< *it <<" ";
        it++;
    }
    cout<<endl;
    return;
}

int main()
{
    int arr[][n] = {{116, 98, 15, 3, 1},
                    {9, 7, 6, 2, 0},
                    {19, 16, 4, 3, 1},
                    {112, 99, 66, 33, 11}};
    int k = sizeof(arr)/sizeof(arr[0]);
    Sort(k-1, arr);
    return 0;
}
#endif