系列文章目录

数据结构之堆_crazy_xieyi的博客-CSDN博客

文章目录

• 前言
• 一、Top-k问题
•         1.前K个最小数（第k个最小数）
•         2.前K个最大数（第K个最大数）
• 二、堆排序
  • 1.从小到大排序（建大根堆）
  • 2.从大到小排序（建小跟堆）

前言

向上调整建堆的时间复杂度为O(nlogn).

一、Top-k问题

示例：在给定的一个数组中求前K个最小的数

第一种思路：把给定的数组直接进行排序，然后前K个一定是最小的数；

 public int[] getLeastNumbers(int[] arr, int k) {Arrays.sort(arr);int[] str = new int[k];for (int i = 0; i < k; i++) {str[i] = arr[i];}return str;}

显然这种方式是不可取的，如果数据量非常大，排序就不太可取了(可能数据都

public static int[] smallestK(int[] arr, int k) {//1. 建立一个小根堆PriorityQueue minHeap = new PriorityQueue<>();//2、取出数组当中的每个元素，存放到小跟堆当中for (int i = 0; i < arr.length; i++) {minHeap.offer(arr[i]);}//3.弹出K个元素，存放到数组当中,返回即可int[] tmp = new int[k];for (int i = 0; i < k; i++) {tmp[i] = minHeap.poll();}return tmp;}

但是你会发现，这种方式虽然可以，但是时间复杂度比较高，还是不可取得。整体建堆的时间复杂度为o(n),然后弹出K次时间复杂度为Klogn，则总体时间复杂度为 O(N + Klogn);

第三种思路：

        public int[] getLeastNumbers(int[] arr, int k) {PriorityQueue minHeap = new PriorityQueue<>(new Comparator() {@Overridepublic int compare(Integer o1, Integer o2) {return o2.compareTo(o1);}});if (arr == null || k == 0)return new int[0];//用K个元素，先建立一个大根堆for (int i = 0; i < k; i++) {minHeap.offer(arr[i]);}//剩余元素与堆元素进行比较for (int i = k; i < arr.length; i++) {if (arr[i] < minHeap.peek()){minHeap.poll();minHeap.offer(arr[i]);}}//返回前K个元素int[] str = new int[k];for (int i = 0; i < k; i++) {str[i] = minHeap.poll();}return str;}

此时时间复杂度为：k + (n-k)logk ,约等于nlogk。

那么现在有一个小问题，就是第K个最小的怎么求？

其实这一点非常简单，求第K个最小的，只需要弹出一次就好了，因为此时是大跟堆，那么第K个最小的肯定就是堆顶的元素。

二、堆排序

    /*** 时间复杂度：*  O(n) + O(n*logn) 约等于 O(nlogn)*  空间复杂度：O(1)*/public void heapSort() {//1.建立大根堆 O(n)createHeap();//2.然后排序int end = usedSize-1;while (end > 0) {int tmp = elem[0];elem[0] = elem[end];elem[end] = tmp;shiftDown(0,end);end--;}}private void shiftDown(int root,int len) {int child = root*2 + 1;while (elem[child] > elem[root]){if (child+1 < len && elem[child] < elem[child+1]){child++;}if (elem[child] > elem[root]){int temp = elem[child];elem[child] = elem[root];elem[root] = temp;child = root;root = (child-1)/2;}else {break;}}}

时间复杂度： O(n) + O(n*logn) 约等于 O(nlogn)
空间复杂度：O(1)