引子：五分钟玩转面试考点-数据结构系列，不会像那种严肃、古板的教科书般的博客文章，而是将晦涩难懂的概念和知识点尽可能幽默的细说出来，或结合生活场景，或从零开始分析。带给大家一个严肃而不失风趣的数据结构。

咳咳：俗话说：脱离业务的技术，就是耍流氓。那么我就要提出这篇文章的灵魂一问了，请听题：

1. 1千万整数找出重复次数最多的100个整数。
2. 如何找出每日访问网站最高的10个IP。
3. 有一个1GB大小的文件，里面的每一行是一个词，词的大小不超过16个字节，内存限制大小是1MB。返回频数最高的100个词。

这个时候，感觉就是M个数中选择N个数 ，就是TOP N问题呀，是不是脑海中不由自主的蹦出了排序算法啦~
哈哈，咱就按照这个思路走。然后，表面不慌，假装思索中ing，其实内心再想：排序算法是啥呀？

这里简单提下：

冒泡排序，核心思想：相邻比较。每次将最大的浮出水面。

快速排序，核心思想：分治法+挖坑填数。每次选择一基数，排序完成左边比基数小，右边比基数大。一直切分（分治），直至选出无序的最大的N个整数。

堆排序（出场自带猪脚光环~），可以创建一个N大小的最小堆。然后balabala。

这时候你可能要打断一下了:啥？最小堆？我这是要选出最大的N个元素呀？有木有搞错？emmm等等，啥叫堆？？？啥叫最小堆？？？为什么不选最大堆呢？？？

请听我戏说一下：

基础概念：

堆：分为最大堆和最小堆，其实就是完全二叉树，最大堆要求父节点的元素都大于等于子节点，最小堆要求父节点元素小于等于子节点。

下面图解下如何生成大根堆：

我就拿（内心PS：读书人的事情，怎么能说偷呢？）一下图吧，放在这里这里让大家容易理解~~
给定一个列表array=[16,7,3,20,17,8]，对其进行堆排序。
首先根据该数组元素构建一个完全二叉树，得到

原始的数据堆

然后需要构造初始堆，则从最后一个非叶节点开始调整，调整过程如下：

第一步：找到最后一个组（非叶节点），左节点8 pk 擂主3，左孩子8胜利！然后3和8互相调换位置。败者3没有子节点，结束比赛。

小组赛第一场.png

从右到左。组内pk，左子树20 pk 右子树17 左子树20胜利，获得挑战擂主7的机会。左子树20 pk 擂主7 左子树20胜利，20和7交换位置。败者7没有子节点，结束比赛。

小组赛第二场

从下到上，左子树20 PK 右子树8，左子树20胜利。获得挑战擂主16的机会。左子树20 pk 擂主16 左子树胜利，交换位置。
此时败者16含有孩子节点，将被挑战。

小组赛第三场！冠军战！

组内挑战开始：左子树7和右子树17组内pk，右子树17胜利。获取挑战擂主16的机会。右子树17和擂主16pk，右子树17胜利，交换位置。败者16无孩子节点，结束比赛。

败者挑战赛

这样就得到了初始堆。

哈哈，相信到这里，基本懂得同学还是懂，不懂得还是一脸XX。这是哪？我在干什么？你是谁？

咱们慢慢分析：

无序数组转化为大根堆步骤：

1.找到最后一个非叶节点，从右到左，从下到上，遍历所有非叶节点；

2.若是父节点小于最大的子节点，那么交换父子节点的位置，但是要注意，交换之后对其他节点的影响。

我们的目标是：
(没有蛀牙....)根节点一定是树中最大的值。同时，父节点大于子节点。

切回到我们的问题。此时，你应该基本知道了堆的概念，为什么不选最大堆呢？因为咱们选最小堆就是采用末位淘汰制。将堆中最小元素剔除。
每次最小堆调整后，总会将整个堆中最小的元素放在根节点上，然后我们分别取出[N-1,M]中的元素，若大于堆顶，则替换。然后（随着堆的蠕动，你可以动态想想这个画面~~）再次将最小元素选出放于堆顶。直至堆里保存的都是最大的元素。

此时，你会想怎么细节怎么实现的：如何确定最后一个非叶节点呢？如何精确找到每一个孩子节点呢？

嘿嘿，我可真是一个小机灵鬼...，放心，全都给你整的明明白白的~

如何确定父节点和子节点的下标位置呢？

(1) 它的左孩子结点是：R[2i+1];
(2) 它的右孩子结点是：R[2i+2];
(3) 它的父结点是：R[(i-1)/2];

骗谁呢？具体解释下，不要粘贴公式糊弄你的小可爱们！哼~

那好，咱们从零分析一下：

还是上面的数组，证据在上面，咱们就开始分析啦：

array=[16,7,3,20,17,8] 一个长度为6的数组。

咱们从i=5，最后一个元素array[5]开始说起：
父节点：(i-1)/2=2，他的父节点就是i=2，array[2]也就是3。
子节点：2i+1=11，等等兄得，你越界了...你根本没有孩子节点...(名侦探小胖)
于是我就大胆推测一下，最后一个非子节点就是array[2]。

反向推理一下：i=2时，左孩子：2i+1=5，右孩子：2i+2=6，但是最大下标是5，那么只有一个孩子节点array[5]也就是8。

那倒数第二个下标非叶节点的下标是啥？
博主内心独白：emmm我也不知道....继续套公式，看看有啥规律不。

数组倒数第二个下标数是i=4，(i-1)/2=1，那么下标array[1]就是第2个父节点。
数组倒数第三个下标数是i=3，(i-1)/2=1，也是下标array[1]。

那倒数第一个下标非叶节点的下标是啥？
数组倒数第四个下标数是i=2，(i-1)/2=1，那么下标array[0]就是第3个父节点。
数组倒数第三个下标数是i=1，(i-1)/2=1，也是下标array[0]。

此时还有吗？
数组倒数第五个下标数是i=0，(i-1)/2=-1，也是下标array[-1]。

也就是根节点没有父节点了....

等等，我好像发现啥规律了...
父节点是array[2]=3 array[1]=7 array[0]=16。
array=[16,7,3,20,17,8]

image

在我找到最后一个非叶节点 i 之后，通过i-1找到其他非叶节点，直到根节点的下标是0。

可是，概念太多，记不住呀。没事，安排好了，结合一个生活场景，真正做到熟记于心~

结合生活场景解释一下：

现在要开始 XX联盟S17 的比赛，比赛组根据玩家投票新采用了一种新的比赛规则，规则如下：

横向：每个新晋擂主可以参与更高一级的比赛，直至选出冠军。登顶大根堆顶峰；

纵向：每个下台擂主要被更低一级的选手挑战，需要证明自己实力，也可能被一撸到底；

简言之：能者上，弱者下
每一小组选出最强者，参与擂主pk，胜利者获取下一次挑战机会；失败者要被挑战，直至完成一场胜利，或者排名倒数。

   //比赛开始-请各小组按顺序进行比赛（从排名最后一个小组开始）
public static int[] createMaxHeap(int[] arr) {
   int length = arr.length;
    //冠军下标是0
    for (int i = (length - 1-1) / 2; i >= 0; i--) {
        //开启小组擂台赛
        doJustHeapMove(arr, i, length);
    }
    return arr;
}

而后，开始了激烈的小组比赛，擂主先把收拾自己的东西，因为他也不知道自己是一败涂地还是保持原位！心里有些忐忑~

//小组擂台开始
private static void doJustHeapMove(int[] arr, int root, int length) {
    int temp = arr[root];  //擂主将自己的东西保存好

    //确定小组成员，确保每一个人都有机会挑战（最后元素:length-1）
    //若发起挑战，擂主失败，那么就会子节点挑战
    //每次开始，均获取到小组成员编号（而开始的root若是挑战失败，便成为了lChild）
    for (int lChild = 2 * root + 1; lChild < length; lChild = 2 * lChild + 1) {
        //判断左节点是否是length-2，即不是最后一个元素！
        //若是最后一个元素，小组只有自己，直接参与擂台赛
        //选出小组最强者，准备参与擂主pk，
        if (lChild < length - 1 && arr[lChild + 1] > arr[lChild]) {
            lChild++;
        }
        //擂台赛开始
        if (temp >= arr[lChild]) {
            break;  //小组擂台赛结束，开始下一小组的比赛
        } else {
            arr[root] = arr[lChild];  //成员升级（擂主）
            root = lChild;   //擂主降级（获取到降级的编号）
        }
    }
    //擂主降级赛结束，灰溜溜的走了~
    arr[root] = temp;
}

我还会回来的(擂主内心独白)~~

力扣解法

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

兜兜转转，从第一篇博客到2021.08.22已经过去了2年半多了。今天又回到这个题目。带来一种最小堆更加简洁的实现。即依赖JDK API来实现最小堆，只需要使得最小堆维护top n个元素即可。

class Solution {
    /**
     * 最小堆实现TOP N
     */
    public int findKthLargest(int[] nums, int k) {
        //定义的最小堆
        PriorityQueue<Integer> queue = new PriorityQueue<>(k, (a, b) -> a - b);

        //最小堆，先入k个元素
        for (int i = 0; i < k; i++) {
            queue.add(nums[i]);
        }
        for (int i = k; i < nums.length; i++) {
            //取出堆顶元素，但不移除
            int min = queue.peek();
            //若num[i]大于堆中最小元素，即堆中最小元素不是Top N
            if (nums[i] > min) {
                //移除堆顶元素
                queue.poll();
                //将元素放入堆中
                queue.offer(nums[i]);
            }
        }
        return queue.peek();
    }
}