【常见算法系列】你真正了解java中的堆吗？

一、二叉堆

1. 二叉堆是一颗二叉树，不一定是满二叉树，但一定是完全二叉树，完全二叉树指的是允许有缺失的部分，但缺失节点的部分一定是右下侧。
2. 最大堆：根节点的元素是最大的元素
3. 最小堆：如果任意一个节点小于等于他的孩子节点
4. 完全二叉树有其非常卓越的性质：对于任意一个父节点的序号n来说（这里n从0算），它的子节点的序号一定是2n+1,2n+2

二、堆排序

堆排序的基本思路：

堆排序的基本思路：

1. 将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
2. 将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
3. 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

 public static void sort(int []arr){
        //1.构建小顶堆
      buildMinDump(arr);
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            minAdjust(arr,0,j);//重新对堆进行调整
        }

    }
    
    public void buildMinDump(int [] input) {
        
        for(int index= input.length/2-1; index>=0;index--) {
            minAdjust(input, index, input.length);
        }
        
    }
    
    public void minAdjust(int [] input, int i, int length) {
        
        int left = 2 * i +1;
        int right = 2 * i +2;
        
        int minIndex = i;
        
        if(left < length && input[left] < input[minIndex]) {
            
            minIndex = left;
        }
        
       if(right < length && input[right] < input[minIndex]) {
            
            minIndex = right;
        }
        
        if(minIndex != i) {
            swap(input, minIndex, i);
            minAdjust(input, minIndex, length);
            
        }
        
        
        
    }
    
    public void swap(int [] input, int i,int j) {
        
        int tmp = input[i];
        input[i] = input[j];
        input[j] = tmp;
    }

三、例子

1、大根堆的应用：数组中的第K个最大元素

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

示例 1:

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

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

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

代码：

class Solution {
    public int findKthLargest(int[] array, int k) {
        buildHeap(array);
        int length = array.length;

        while (k > 1) {
            swap(array, length - 1, 0);
            length--;

            maxAdjust(array, 0, length);
            k--;
        }
        return array[0];
    }

    public void buildHeap(int[] array) {

        for (int i = array.length / 2; i >= 0; i--) {
            maxAdjust(array, i, array.length);
        }
    }

    public void maxAdjust(int[] array, int i, int length) {

        int maxIndex = i;

        int l = 2 * i + 1;
        int r = 2 * i + 2;
        if (l < length &&   array[l] > array[maxIndex]) {
            maxIndex = l;
        }

        if (r < length &&  array[r] > array[maxIndex]) {
            maxIndex = r;
        }

        if (maxIndex != i) {
            swap(array, maxIndex, i);
            maxAdjust(array, maxIndex, length);

        }
    }

    private void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;

    }
}

2、小根堆的应用：最小K个数

设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

示例：

输入： arr = [1,3,5,7,2,4,6,8], k = 4
输出： [1,2,3,4]
提示：

0 <= len(arr) <= 100000
0 <= k <= min(100000, len(arr))

代码：

class Solution {
     public int[] smallestK(int[] array, int k) {
        buildHeap(array);

        int[] resArray = new int[k];
        int length = array.length;
        for (int i = 0; i < k; i++) {

            resArray[i] = array[0];
            swap(array, length - 1, 0);
            length --;
            smallestAdjust(array, 0, length);
//            k--;
        }
        return resArray;
    }

    private void buildHeap(int[] array) {

        for (int i = array.length; i >= 0; i--) {
            smallestAdjust(array, i, array.length);
        }
    }

    private void smallestAdjust(int[] array, int i, int length) {

        int smallestIndex = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;

        if (left < length && array[left] < array[smallestIndex]) {

            smallestIndex = left;
        }

        if (right < length && array[right] < array[smallestIndex]) {

            smallestIndex = right;
        }

        if (smallestIndex != i) {

            swap(array, smallestIndex, i);
            smallestAdjust(array, smallestIndex, length);
        }


    }

    private void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;

    }
}

解法二：

 public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        
        if(input == null || input.length ==0 || k > input.length || k <=0) {
            return new ArrayList<Integer>();
        }
        
       PriorityQueue<Integer> queue = new PriorityQueue<Integer>((num1, num2) -> num2-num1);
        
        
        for(int i=0; i< input.length; i++) {
            
             if(i < k) {
                 queue.offer(input[i]);
                continue;
            }
            
             if(queue.peek() > input[i]) {
                 queue.poll();
                 queue.offer(input[i]);
            }
         }
        
         ArrayList<Integer> resList = new  ArrayList<Integer>();
         for(int i=0; i< k; i++) {
             resList.add(queue.poll());
        }
        
         return resList;
       

        
    }

关于面试哪些事，欢迎关注公众号“程序员ZZ的源码”