堆

堆是一种二叉树结构

1.堆是一个完全二叉树（从上到下，从左到右依次填满）

2.堆中的每一个节点都要大于等于他的孩子节点（最大堆）或者小于等于他的孩子节点（最小堆）

最大堆的堆顶元素是他的最大值，最小堆的堆顶元素是他的最小值

访问（堆里面不通过索引访问）

搜索O（1）一般只查看堆顶元素

添加O（logN）插入数据先添加到最底层的叶子节点，然后逐层向上交换

删除O（logN）删除指的是删除对顶元素，删除之后需要把左右孩子节点的最大值移上去

常用操作：

1.创建堆，最大堆，最小堆

2.添加元素

3.获取堆顶元素

4.删除堆顶元素

5.堆的长度

6.堆的遍历

 

215

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

 

示例 1:

输入: [3,2,1,5,6,4], k = 2
输出: 5
示例 2:

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4
 

提示：

1 <= k <= nums.length <= 105
-104 <= nums[i] <= 104

 

class Solution {
public:
    void swim(std::vector<int> &nums, int i)
    {
        while (i > 0)
        {
            if (nums[i] < nums[(i - 1) / 2])
            {
                swap(nums[i], nums[(i - 1) / 2]);
                i = (i - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }

    void sink(std::vector<int> &nums, int i, int end)
    {
        // 有左孩子
        while (2 * i + 1 <= end)
        {
            // 左孩子下标
            int j = 2 * i + 1;
            // 有右孩子
            if (j + 1 <= end)
            {
                if (nums[j] > nums[j + 1])
                {
                    // 获取最小孩子节点的下标
                    j = j + 1;
                }
            }
            // 父节点比子节点小，无需继续
            if (nums[i] < nums[j])
            {
                break;
            }
            // 父节点和最小的子节点交换位置
            swap(nums[i], nums[j]);
            // 继续下沉
            i = j;
        }
    }

    int findKthLargest(vector<int>& nums, int k) {
        //std::sort(nums.begin(), nums.end(), [](int a, int b){return a > b;});
        for (int i = 0; i < k; ++i)
        {
            swim(nums, i);
        }
        for (int i = k; i < nums.size(); ++i)
        {
            if (nums[i] > nums[0])
            {
                swap(nums[i], nums[0]);
                sink(nums, 0, k - 1);
            }
        }
        return nums[0];
    }
};