堆排序：比较方式为小于建大堆

        priority_queue(Iterator first, Iterator last)
			: _con(first, last) // 1、使用vector的区间构造函数来初始化_con
		{
			// 2、建堆：从完全二叉树的最后一个非叶子结点来进行向下调整
			for (int i = (size() - 2) / 2; i >= 0; i--)
			{
				AdjustDown(i);
			}
		}

		void priority_queue_sort()
		{
			size_t end = size() - 1;
			vector<int> res;
			while (!empty())
			{
				res.push_back(_con[0]);
				pop();
			}
			for (auto e : res)
				cout << e << " ";
			cout << endl;
		}

215. 数组中的第K个最大元素 TopK

给定整数数组 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

【解法一】排序返回

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        return nums[nums.size()-k];
        
        #include<functional>
        sort(nums.begin(), nums.end(), greater());
        return nums[k-1];
    }
};

【解法二】利用priority_queue的默认less来建大堆，popk-1次，返回堆顶即可

        priority_queue<int> q(nums.begin(), nums.end());
        for(int i = 1; i < k; i++)
        {
            q.pop();
        }
        return q.top();

【TopK引论】

    // 求该数组中前k个元素
    vector findKthLargest(vector<int>& nums, int k) {
        // 1、创建一个小根堆，最小的元素放堆顶
        priority_queue<int, vector<int>, Greater<int>> q;
        for(int i = 0; i < size(); i++)
        {
            // 2、前k个直接放入q中
            if(i < k)
                q.push(nums[i]);
            else
            {
                // 大于堆顶元素就将堆顶元素删除，并将nums[i]放入q中
                if(nums[i] > q.top())
                {
                    q.pop();
                    q.push(nums[i]);
                }
            }
        }
        return q;
    }

void AdjustDown(int array[], int size, int parent)
{
    int child = parent * 2 + 1;
    while (child < size)
    {
        if (child + 1 < size && array[child] > array[child + 1])
        {
            child = child + 1;
        }
        if (array[parent] > array[child])
        {
            Swap(&array[parent], &array[child]);
            parent = child;
            child = 2 * child + 1;
        }
        else
            return;
    }
}

void Heapsort(int array[], int size)
{
    // 堆排序
    // 首先进行建堆  降序建小队 升序建大堆
    for (int root = (size - 2) / 2; root >= 0; --root)
    {
        AdjustDown(array, size, root);
    }
 
    int end = size - 1;
    while (end)
    {
        // 利用堆删除的思想
        // 将堆尾元素与堆顶元素进行交换
        Swap(&array[end], &array[0]);
        // 再将堆顶进行向下调整即可   如此循环将每个元素进行排序
        AdjustDown(array, end, 0);
        end--;
    }
    Print(array, size);
}