leetcode 剑指offer面试题40. 最小的k个数

题干：
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]

限制：
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

解题方法：
1.快速排序：将给出的数组由小到大排列，取前k个数输出。方法简单，但时间复杂度高，O(nlogn)
2.堆排序：利用堆排序的思想，排列数组，时间复杂度O(nlogk)。
堆排序的步骤：
1.构造一个大根堆，即每个父节点都比他的子节点大。
2.将栈顶元素和末尾元素交换，得到最大值，反复重复该步骤，知道升序排列数组

代码实现：

void swap(int* arr, int a, int b){          //定义一个交换函数
    int tmp = arr[b];
    arr[b] = arr[a];
    arr[a] = tmp;
}

void heapify(int* arr, int i, int len){     //构造初始堆
    int lc = 2 * i + 1;                     //左子树      
    int rc = 2 * i + 2;                     //右子树
    int max = i;
    if (lc < len && arr[lc] > arr[max]){    //如果左子树的值大于父节点
        max = lc;
    }
    if (rc < len && arr[rc] > arr[max]){    //如果右子树的值大于父节点
        max = rc;
    }
    if (max != i){                          //如果最大值不是父节点
        swap(arr, i, max);                  //交换最大子节点和父节点
        heapify(arr, max, len);             //递归向下运算将堆排列好
    }
}

void biuld_heap(int* arr, int len){         //建立一个大根堆
    int last_node = len - 1;                
    int parent = (last_node - 1) / 2;       //从倒数第二层开始并往回heapify
    int i;
    for (i = parent; i >= 0; i--){          //
        heapify(arr, i, len);
    }
}

void heapsort(int* arr, int len){           //构造堆排序函数，可将数据由小到大排列出来
    biuld_heap(arr, len);                   //建立一个大根堆
    int i;
    for (i = len - 1; i >= 0; i--){       
        swap(arr, i, 0);                    //将最后一个节点和根节点交换，得到最大的数
        heapify(arr, 0, i);                 //对剩下的堆进行heapify
    }
}

int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){
    heapsort(arr, arrSize);
    * returnSize = k;
    int* nums = (int*)malloc(sizeof(int) * k);
    int i;
    for (i = 0; i < k; i++){
        nums[i] = arr[i];
    }
    return nums;
}

注意：
void main、int main、和int main(void)的区别：
1、区别是main()函数是否有返回值。
2、void定义的函数没有返回值，int定义的函数返回整型值。
3、void，字面意思是“无类型”，常用在程序编写中对定义函数的参数类型、返回值、函数中指针类型进行声明，有注释和限制程序的作用。