算法17：堆结构_相关面试题
什么是堆结构
1）堆结构就是用数组实现的完全二叉树结构
2）完全二叉树中如果每棵子树的最大值都在顶部就是大根堆
3）完全二叉树中如果每棵子树的最小值都在顶部就是小根堆
4）堆结构的heapInsert与heapify操作
5）堆结构的增大和减少
6）优先级队列结构，就是堆结构
如何构建堆结构？
package code2.排序_03.堆排序; /** * 构建大根堆 */ public class Code01_MyMaxHeap { private int limit; private int[] heap; private int size; public Code01_MyMaxHeap(int limit) { this.limit = limit; heap = new int[this.limit]; size = 0; } private void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } //上移式构建大根堆 public void heapInsert (int[] arr, int index) { while (index < this.limit && arr[index] > arr[(index-1)/2]) { swap(arr, index, (index-1)/2); index = (index-1)/2; } } //下层式构建大根堆 public void heapify(int[] arr, int index, int length) { /** * 二叉树性质5： * 1. 如果index为0，则代表这是第一个节点,则无双亲节点 * 2. 如果index*2 > n(n代表长度)，则节点无左孩子。 java中下标是从0开始，因此 index*2 + 1 > n * 3. 如果index*2+1 >n, 则代表无右孩子。 java中下标是从0开始，因此 index*2 + 2 > n */ int left = index * 2 + 1; while (left < length) { int bigger = (left + 1) < length && arr[left] < arr[left + 1] ? left + 1: left; if(arr[index] >= arr[bigger]) { break; } swap(arr, index, bigger); index = bigger; left = index * 2 + 1; } } public void push1(int value) { if (size == this.limit) { throw new RuntimeException("堆已满，无法添加新数据！"); } heap[size] = value; heapInsert(heap, size++); } public void push2(int[] arr) { if (size == this.limit) { throw new RuntimeException("堆已满，无法添加新数据！"); } heap = arr; for (int i = arr.length-1; i >=0; i--,size++) { heapify(heap, i, arr.length); } } public int pop() { if (size < 0) { throw new RuntimeException("堆为空，无法获取值"); } int ans = heap[0]; //swap(heap, 0, heap.length -1); /** * 好处： * 1. --size正好和数组长度相同 * 2. 在heapify中，作为数组长度使用。变相的减少了1个长度。 * 使最后的11不在作为父节点下沉的判断条件。参考代码36行 */ swap(heap, 0, --size); heapify(heap, 0, size); return ans; } public static void main(String[] args) { //case 1: 上移式构建大根堆，结果是11,7,8,6,4,7,0,3 /* int[] arr = {3,7,11,4,6,8,0,7}; MyMaxHeap my = new MyMaxHeap(arr.length); for (int i =0; i < arr.length; i++) { my.push1(arr[i]); }*/ //case 2: 下沉式构建大根堆。 大根堆的结果是11,7,8,7,6,3,0,4 int[] arr = {3,7,11,4,6,8,0,7}; Code01_MyMaxHeap my = new Code01_MyMaxHeap(arr.length); my.push2(arr); //case 3: 删除大根堆最大值，要求剩下的节点依旧维持大根堆的结构 int value = my.pop(); System.out.println("弹出值为：" + value); } }
上面的代码不难，相信阅读完代码以后，会对堆结构有一点了解。提到堆结构，离不开的就是堆排序问题了。
堆排序
package code2.排序_03.堆排序; /** * 构建大根堆 * 1，先让整个数组都变成大根堆结构，建立堆的过程: * 1)从上到下的方法，时间复杂度为O(N*logN) * 2)从下到上的方法，时间复杂度为O(N) * 2，把堆的最大值和堆末尾的值交换，然后减少堆的大小之后，再去调整堆，一直周而复始，时间复杂度为O(N*logN) * 3，堆的大小减小成0之后，排序完成 */ public class Code02_HeapSort { private void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public void printArray(int[] arr) { if (arr == null) { return; } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } public int[] heapSort(int[] arr) { if (arr == null || arr.length < 2) { return arr; //不满足条件，就返回原数组 } int size = arr.length; //首先构造大根堆, 从下网上，时间复杂度为O(N) for (int i = size-1; i>=0; i--) { heapify(arr, i, size); } //将最大值放在大根堆的最后 swap(arr, 0, --size); //迭代，重新生成大根堆，并且将最大值放在最后. //因为第一次已经交换完毕，所以接下来的会逐个减少，知道最后一个是根元素为止 while(size > 0) { /*for (int i = size; i>=0; i--) { heapify(arr, i, size); }*/ //下面一行代码，等价与上方的一个for循环。 for循环是从数组的最后 //一个元素开始下沉。而下方代码是基于上一次调整完成以后，新的数组的根节点开始下沉 //从上往下，时间复杂度为O(N*logN) heapify(arr, 0, size); swap(arr, 0, --size); } return arr; } //下层式构建大根堆 public void heapify(int[] arr, int index, int length) { /** * 二叉树性质5： * 1. 如果index为0，则代表这是第一个节点,则无双亲节点 * 2. 如果index*2 > n(n代表长度)，则节点无左孩子。 java中下标是从0开始，因此 index*2 + 1 > n * 3. 如果index*2+1 >n, 则代表无右孩子。 java中下标是从0开始，因此 index*2 + 2 > n */ int left = index * 2 + 1; while (left < length) { int bigger = (left + 1) < length && arr[left] < arr[left + 1] ? left + 1: left; if(arr[index] >= arr[bigger]) { break; } swap(arr, index, bigger); index = bigger; left = index * 2 + 1; } } public static void main(String[] args) { //case 2: 下沉式构建大根堆。 大根堆的结果是11,7,8,7,6,3,0,4 int[] arr = {3,7,11,4,6,8,0,7}; Code02_HeapSort heap = new Code02_HeapSort(); int[] sortArr = heap.heapSort(arr); heap.printArray(sortArr); } }
了解堆结构和堆排序只是基础，有了以上的铺垫，才能更好的帮助我们理解堆相关的算法以及面试题。
算法一：已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k，并且k相对于数组长度来说是比较小的。请选择一个合适的排序策略，对这个数组进行排序。
这道题，其实想要考查的就是堆的相关知识。试想一下，如果k是一个比较小的数，例如3. 每个元素移动的距离一点不会超过3. 假设，每个数移动距离都是都是最大距离 3，那么如果数组下标为 0,1,2怎么办 ？必然只有往后移动才可以. 而从 k + 1开始，也就是从4开始，数据既可以往前移动，也可以往后移动。 于此同时，当 数据达到4个的时候，前 个数必然能确定一个最小值（或者最大值），因为每个元素移动的距离一定不超过k。 借助于堆结构对象 PriorityQueue 便能够很好的解决这个问题。 代码如下：
package code2.排序_03.堆排序; import jdk.internal.org.objectweb.asm.util.CheckAnnotationAdapter; import java.util.Arrays; import java.util.PriorityQueue; /** * 已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k，并且k相对于数组长度来说是比较小的。 * 请选择一个合适的排序策略，对这个数组进行排序。 */ public class Code03_HeapSortForLenthLessK { public static void printArray(int[] arr) { if (arr == null) { return; } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } // for test public static int[] randomArrayNoMoveMoreK(int maxSize, int maxValue, int k) { double val = Math.random(); int[] arr = new int[(int) ((maxSize + 1) * val)]; for (int i = 0; i < arr.length; i++) { arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random()); } // 先排个序 Arrays.sort(arr); // 然后开始随意交换，但是保证每个数距离不超过K // swap[i] == true, 表示i位置已经参与过交换 // swap[i] == false, 表示i位置没有参与过交换 boolean[] isSwap = new boolean[arr.length]; for (int i = 0; i < arr.length; i++) { int j = Math.min(i + (int) (Math.random() * (k + 1)), arr.length - 1); if (!isSwap[i] && !isSwap[j]) { isSwap[i] = true; isSwap[j] = true; int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } } return arr; } public static void sort (int[] arr, int k) { if (arr == null || arr.length < 2 || k == 0) { return ; } //利用系统提供的堆结构，可以直接实现数组的排序 PriorityQueue<Integer> heap = new PriorityQueue<>(); int index = 0; /** * 每个数组的移动距离都不超过k, 也就是每个数组要么最多往前移动k个， * 要么最多往后移动k个数。 * 从0 到 k-1, 如果要想移动k个数，那么只能往后移动，如果是往前移动 * 那么丢在系统堆中会默认进行排序 */ for (;index <= k-1;index++) { heap.add(arr[index]); } int i = 0; /** * 从此时开始，数据存在往前移动或者往后移动 k 个数的情况 * 因此，如果是往前移动 k 个，那么丢入堆中，poll（）出来的必然是最新一次丢入 * 的数据； 如果是往后移动k个，那么堆中的最小值肯定是之前丢进去的，直接拿出来即可 * * 假设k =5， {6,5,4,3,2}, 那么如果出现 1, 那么poll出来的必然是1. 因为数组基本 * 有序且最多移动不超过k， 那么从左到右出现 k+1个数的时候，此时必然存在最小数 */ for (; index < arr.length; index++, i++) { heap.add(arr[index]); arr[i] = heap.poll(); } while (!heap.isEmpty()) { arr[i++] = heap.poll(); } } public static void main(String[] args) { int maxSize = 100; int maxValue = 100; int k = 5; int[] arr = randomArrayNoMoveMoreK(maxSize,maxValue,k); //排序前 printArray(arr); sort(arr, k); //排序后 printArray(arr); } }
算法二 ：最大线段重合问题（用堆实现）
给定很多线段，每个线段都有两个数[start, end]，表示线段开始位置和结束位置，左右都是闭区间
规定：
1）线段的开始和结束位置一定都是整数值
2）线段重合区域的长度必须>=1
返回线段最多重合区域中，包含了几条线段
解题思路：这个题中每个线段都有一个开始位置start 和 一个结束位置 end。 如果我们按照开始位置start进行初次排序，则会得到一个开始位置有序的线段数组，类似于 {{1，7}， {1,6}, {2,5}, {,63}......}. 然后再遍历数组每个线段的开始位置和结束位置。如果新线段开始的位置值（已经有序）大于堆结构中存储的线段末尾值，那么删除对中对应数据，并且将新线段的 end值存入数组中。为什么能这么操作？因为一开始我们便对线段的start进行了排序，以后的线段只能大于或者等于现在的线段的start值，这一点是非常重要。
package code2.排序_03.堆排序; import java.util.Arrays; import java.util.Comparator; import java.util.PriorityQueue; /** * 最大线段重合问题（用堆的实现） * 给定很多线段，每个线段都有两个数[start, end]， * 表示线段开始位置和结束位置，左右都是闭区间 * 规定： * 1）线段的开始和结束位置一定都是整数值 * 2）线段重合区域的长度必须>=1 * 返回线段最多重合区域中，包含了几条线段 */ public class Code04_MaxLineSegment { class Line { public int start; public int end; Line(int start,int end) { this.start = start; this.end = end; } } class MyComparator implements Comparator<Line> { @Override public int compare(Line o1, Line o2) { return o1.start - o2.start; } } /** * 随机构造线段 * @param N 代码线段的条数 * @param L 代表线段的开始值 * @param R 代表线段的结束值 * @return */ public int[][] generateLines(int N, int L, int R) { int size = (int) (Math.random() * N) + 1; int[][] ans = new int[size][2]; for (int i = 0; i < size; i++) { int a = L + (int) (Math.random() * (R - L + 1)); int b = L + (int) (Math.random() * (R - L + 1)); if (a == b) { b = a + 1; } ans[i][0] = Math.min(a, b); ans[i][1] = Math.max(a, b); } return ans; } public int maxValue (int[][] segments) { Line[] lines = new Line[segments.length]; for(int i =0; i < segments.length; i++) { int[] arr = segments[i]; lines[i] = new Line(arr[0], arr[1]); } //按照Line对象的start进行排序 //end > start, 所以此处的排序非常重要 //比如, m = { {5,7}, {1,4}, {2,6} } 跑完如下的code之后变成：{ {1,4}, {2,6}, {5,7} } Arrays.sort(lines, new MyComparator()); //小根堆，默认升序 PriorityQueue<Integer> queue = new PriorityQueue(); int max = 0; for (Line line : lines) { //正因为右了上方Arrays.sort的排序，我们才可以进行此处while的操作 while (!queue.isEmpty() && queue.peek() <= line.start) { queue.poll(); } queue.add(line.end); //这一段代码用的非常的巧妙。举个例子{{1,3},{1,4},{2,5},{4,8}} //{2,3}共出现了3次,{4,8}出现的时候会将1,3},{1,4}都删除。此时的size为2, //但是，我们依旧可以获得最大值为3 max = Math.max(max, queue.size()); } return max; } //仅仅为了测试而准备 public int maxCover1(int[][] lines) { int min = Integer.MAX_VALUE; int max = Integer.MIN_VALUE; for (int i = 0; i < lines.length; i++) { min = Math.min(min, lines[i][0]); max = Math.max(max, lines[i][1]); } int cover = 0; for (double p = min + 0.5; p < max; p += 1) { int cur = 0; for (int i = 0; i < lines.length; i++) { if (lines[i][0] < p && lines[i][1] > p) { cur++; } } cover = Math.max(cover, cur); } return cover; } public static void main(String[] args) { /** * 首先测试简单case * {{1,5},{2,9},{1,4},{1,3}，{1,,6}} ==> 我们知道重合最多的的是{2,3}，共计5次 */ Code04_MaxLineSegment test = new Code04_MaxLineSegment(); //int[][] arr = {{1,5},{2,9},{1,4},{1,3},{1,6}}; int[][] arr = {{1,3},{1,4},{2,5},{4,8}}; int max = test.maxValue(arr); System.out.println("最多处包含的线段为： " + max); //下面进行一些大批量随机数的测试 int N = 100; int L = 0; int R = 200; int testTimes = 200000; System.out.println("test end"); for (int i = 0; i < testTimes; i++) { int[][] lines = test.generateLines(N, L, R); int ans1 = test.maxCover1(lines); int ans2 = test.maxValue(lines); if (ans1 != ans2) { System.out.println("Oops!"); } } System.out.println("test end"); } }
算法三：手写加强堆
系统提供的堆无法做到的事情：
1）已经入堆的元素，如果参与排序的指标方法变化，
系统提供的堆无法做到时间复杂度O(logN)调整！都是O(N)的调整！
2）系统提供的堆只能弹出堆顶，做不到自由删除任何一个堆中的元素，
或者说，无法在时间复杂度O(logN)内完成！一定会高于O(logN)
根本原因：无反向索引表
所以，有了加强堆，我们便可以新增很多新的功能。比如，删除堆中的任意一个元素，修改任意一个元素的值等等。所以，手写加强对非常的重要。
package code2.排序_03.堆排序; import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.List; /** * 系统提供的堆无法做到的事情： * 1）已经入堆的元素，如果参与排序的指标方法变化， * 系统提供的堆无法做到时间复杂度O(logN)调整！都是O(N)的调整！ * 2）系统提供的堆只能弹出堆顶，做不到自由删除任何一个堆中的元素， * 或者说，无法在时间复杂度O(logN)内完成！一定会高于O(logN) * 根本原因：无反向索引表 */ public class Code05_EnhanceHeap<T> { private ArrayList<T> heap; //动态数组替换 int[] private HashMap<T, Integer> indexMap; //索引表 private int heapSize; private Comparator<? super T> comp; //比较器，可以根据客户提供的比较器进行升序和降序排序 Code05_EnhanceHeap(Comparator<? super T> comp) { heap = new ArrayList<>(); indexMap = new HashMap<>(); heapSize = 0; this.comp = comp; } private void swap(int i, int j) { T o1 = heap.get(i); T o2 = heap.get(j); heap.set(i, o2); heap.set(j, o1); indexMap.put(o2, i); indexMap.put(o1, j); } private void resign(T obj) { //下面两个方法只会执行其中的一个 heapInsert(indexMap.get(obj)); heapify(indexMap.get(obj)); } private void heapInsert (int index) { //大根堆還是小根堆，完全取決於比較器。 //如果比較器默認是升序，則生成大根堆 //如果比較器默認是降序，則生成小根堆 while (comp.compare(heap.get(index), heap.get((index-1)/2)) < 0) { swap(index, (index-1)/2); index = (index-1)/2; } } private void heapify(int index) { /** * 二叉树性质5： * 1. 如果index为0，则代表这是第一个节点,则无双亲节点 * 2. 如果index*2 > n(n代表长度)，则节点无左孩子。 java中下标是从0开始，因此 index*2 + 1 > n * 3. 如果index*2+1 >n, 则代表无右孩子。 java中下标是从0开始，因此 index*2 + 2 > n */ int left = index * 2 + 1; while (left < heapSize) { int best = (left + 1) < heapSize && comp.compare(heap.get(left+1), heap.get(left)) < 0 ? left + 1: left; //父节点小於等于子节点，无需下沉 if(comp.compare(heap.get(index), heap.get(best)) <= 0) { break; } swap(index, best); index = best; left = index * 2 + 1; } } public boolean isEmpty () { return heapSize == 0; } public int size () { return heapSize; } public boolean contains(T obj) { return indexMap.containsKey(obj); } public T peek() { return heap.get(0); } public void push(T obj) { heap.add(obj); indexMap.put(obj, heapSize); heapInsert(heapSize++); } //删除堆顶 public T pop() { T ans = heap.get(0); swap(0, heapSize-1); indexMap.remove(ans); heap.remove(--heapSize); //此处删除，实际上heap中元素就被删除了，长度需要减1 heapify(0); return ans; } // 请返回堆上的所有元素 public List<T> getAllElements() { List<T> ans = new ArrayList<>(); for (T c : heap) { ans.add(c); } return ans; } public void remove(T obj) { T replace = heap.get(heapSize - 1); //记录最后一个元素 int index = indexMap.get(obj); //获取要删除数的索引 indexMap.remove(obj); //从索引表中删除当前数 heap.remove(--heapSize); //从堆中删除最后一个数 if (obj != replace) { heap.set(index, replace); indexMap.put(replace, index); resign(replace); } } public static void printArray(List list) { if (list == null || list.isEmpty()) { return; } for (int i = 0; i < list.size(); i++) { Customer c = (Customer) list.get(i); System.out.println(c.toString()); } System.out.println(); } static class Customer { int id; int age; String name; Customer(int id, int age, String name) { this.id = id; this.name = name; this.age = age; } @Override public String toString() { return "id :" + id + " age: " + age + " name " + name; } } static class MyIdComprator implements Comparator<Customer> { /** * 統一規範 * 如果為負數, 認為第一個數排前面 * 如果整數，認為第二個數排前面 * 0 無所謂 * @param o1 * @param o2 * @return */ @Override public int compare(Customer o1, Customer o2) { //按照id排序，如果ID相同则按照年龄进行排序 return o1.id - o2.id; } } public static void main(String[] args) { //case1: 测试加强堆的构建 Code05_EnhanceHeap test = new Code05_EnhanceHeap(new MyIdComprator()); test.push(new Customer(1, 11, "zhangsan")); Customer c2 = new Customer(5, 12, "lisi"); test.push(c2); test.push(new Customer(2, 16, "malong")); test.push(new Customer(3, 11, "haoy")); test.push(new Customer(4, 13, "pp")); Customer c6 = new Customer(6, 12, "cy"); test.push(c6); test.push(new Customer(2, 15, "leo")); test.push(new Customer(7, 12, "kiki")); printArray(test.getAllElements()); //case2：测试常用方法 System.out.println("============case 2============="); System.out.println(test.isEmpty()); System.out.println(test.contains(c2)); System.out.println(test.size()); System.out.println(test.peek()); //peek是获取不删除 System.out.println(test.size()); //case3 测试删除一个节点，并且还是保大根堆结构 System.out.println("============case 3============="); test.pop(); printArray(test.getAllElements()); System.out.println("============case 4============="); test.push(new Customer(9, 12, "yy")); printArray(test.getAllElements()); System.out.println("============case 5============="); test.remove(c6); printArray(test.getAllElements()); System.out.println(test.contains(c6)); System.out.println("============case 6 取出全部元素，看看是否有序============="); int i =0; while (!test.isEmpty()) { System.out.println(" 第 " + i + " 次：" + test.pop()); } } }
