堆原理分析及优先级队列实现

忘是亡心i 2024-03-27 09:32 174阅读 0赞

前言

堆是一颗具有特定性质的二叉树，基于堆可以实现优先级队列，在搜索，插入和删除操作上的时间复杂度均为O(logn)，在找到最大或最小元素操作上的时间复杂度均为O(1)。本篇文章将对堆的原理和性质进行分析，并提供基于JAVA语言的堆的实现，最后会再基于堆，实现一个简单优先级队列。

正文

一. 堆的定义

堆的定义如下所示。

  • 堆是一颗完全二叉树；
  • 父节点的元素如果总是大于等于子节点，称之为大根堆；
  • 父节点的元素如果总是小于等于子节点，称之为小根堆。

要理解堆，首先需要了解什么是完全二叉树。完全二叉树定义为：如果二叉树的深度为h，那么除第h层外，其余第1到h-1层的节点数都达到最大值，第h层的所有节点都连续集中在左边。一颗完全二叉树如下所示。

在这里插入图片描述

大根堆如下所示。

在这里插入图片描述

小根堆如下所示。

在这里插入图片描述

通常，堆中元素用一个数组来存放。以上图的小根堆为例，节点旁边的数字代表当前节点在数组中的索引，可以发现其规律就是：按照层序遍历的方式遍历完全二叉树，并每遍历一个节点就将当前节点的元素添加到数组中。所以上图的小根堆以数组表示如下。

在这里插入图片描述

最后，可以根据堆中某个节点在数组中的索引来计算这个节点的左右子节点和父节点在数组中的索引。计算的JAVA代码如下所示。

  1. public class HeapTry {
  4.     public int getLeft(int i) {
  6.         return (i + 1) * 2 - 1;
  7.     }
  9.     public int getRigth(int i) {
  11.         return (i + 1) * 2;
  12.     }
  14.     public int getParent(int i) {
  16.         if (i == 0) {
  18.             return 0;
  19.         }
  20.         return (i - 1) / 2;
  21.     }
  23.     // 省略其它
  25. }

二. 堆的性质

  • 大根堆的性质：父节点的元素总是大于等于子节点
  • 小根堆的性质：父节点的元素总是小于等于子节点

以小根堆为例，考虑这样一个场景：给定一个小根堆，然后将根节点的元素删除并为根节点添加一个新的元素，新的元素不满足小于等于子节点的元素，此时小根堆的性质遭到破坏。图示如下。

在这里插入图片描述

对于上述场景，如果需要恢复小根堆的性质，则以根节点作为第一个父节点，按照如下步骤执行。

  1. 将父节点与子节点的元素进行比较并得到元素最小的节点，如果元素最小的节点是父节点，那么已经恢复小根堆的性质，执行结束；如果元素最小的节点是某个子节点，执行步骤2；
  2. 将父节点与元素最小的子节点互换元素，由于互换元素后子节点有可能破坏小根堆性质，因此从子节点开始，执行步骤1，直到恢复小根堆性质。

图示如下。

在这里插入图片描述

将恢复小根堆性质的算法用JAVA代码实现如下。

  1. public class HeapTry {
  4.     // 省略其它
  6.     public void keepHeap(int[] array, int i, int size) {
  8.         // 通过父节点计算左右子节点的数组索引
  9.         int left = getLeft(i);
  10.         int rigth = getRigth(i);
  12.         // 最小节点的数组索引
  13.         int smallest;
  15.         // 比较得到父节点和子节点中的最小节点的数组索引
  16.         if (left < size) {
  18.             smallest = (array[i] <= array[left]) ? i : left;
  19.         } else {
  21.             smallest = i;
  22.         }
  23.         if (rigth < size) {
  25.             smallest = (array[smallest] <= array[rigth]) ? smallest : rigth;
  26.         }
  28.         // 如果i与smallest不相等，表明父节点不满足小于等于子节点
  29.         // 将父节点元素与最小子节点元素进行交换
  30.         if (i != smallest) {
  32.             int temp = array[i];
  33.             array[i] = array[smallest];
  34.             array[smallest] = temp;
  35.             // 递归以防止交换后子节点不满足小根堆性质
  36.             keepHeap(array, smallest, size);
  37.         }
  38.     }
  40. }

大根堆与小根堆类似，这里就不再举大根堆的例子了。

三. 堆的构建

如果给定一个数组，里面元素并没有按照堆的性质进行放置，此时若需要根据数组中的元素构建一个堆，则应该让所有非叶子节点保持堆的性质（叶子节点总是满足堆的性质）。已经知道，一个堆的叶子节点总是在数组的最后部分，因此通过计算最后一个叶子节点（即数组中的最后一个位置）的父节点，就可以得到最后一个非叶子节点，该非叶子节点往前的所有节点都是非叶子节点，所以从最后一个非叶子节点开始往前，让每一个非叶子节点保持堆的性质，就可以构建一个堆。图示如下。

在这里插入图片描述

可以看到，叶子节点总是在数组的最后部分，并且通过计算最后一个叶子节点（数组索引为5）的父节点可以得到最后一个非叶子节点（数组索引为2）。

构建堆的JAVA代码如下所示。

  1. public class HeapTry {
  4.     // 省略其它
  6.     public void createHeap(int[] array, int size) {
  8.         // 计算最后一个非叶子节点的数组索引
  9.         int lastParent = getParent(size - 1);
  11.         // 从最后一个非叶子节点往前遍历每一个非叶子节点，并让每个非叶子节点保持堆性质
  12.         for (int i = lastParent; i >= 0; i--) {
  14.             keepHeap(array, i, size);
  15.         }
  16.     }
  18. }

四. 堆的排序

因为小根堆的根节点的元素总是整个堆中的最小元素，大根堆的根节点的元素总是整个堆中的最大元素，因此可以基于堆的性质实现排序算法（通常小根堆实现降序排序，大根堆实现升序排序）。给定一个小根堆，且一共有n个元素，堆排序算法步骤如下。

  1. 将小根堆的根节点与堆最后一个节点互换元素，然后执行步骤2；
  2. 将前n-1个节点重新构建一个小根堆，并且令n=n-1，如果n为0则排序结束，否则执行步骤1。

图解流程如下所示。

在这里插入图片描述

堆排序（小根堆）的JAVA代码如下所示。

  1. public class HeapTry {
  4.     // 省略其它
  6.     public void heapSort(int[] array, int size) {
  8.         if (size == 0) {
  10.             return;
  11.         }
  12.         while (size > 0) {
  14.             int temp = array[0];
  15.             array[0] = array[size - 1];
  16.             array[size - 1] = temp;
  17.             createHeap(array, size - 1);
  18.             size = size - 1;
  19.         }
  20.     }
  22. }

五. 插入和删除

如果要基于堆实现一个优先级队列，那么堆需要能够支持插入和删除元素。首先是元素的插入，以小根堆为例，将需要插入的元素添加到堆的最后以生成最后一个叶子节点，然后将其和父节点进行比较，如果其小于父节点则和父节点互换元素，然后继续和新位置对应的父节点进行比较，直到插入的元素大于等于父节点或者插入的元素成为根节点的元素为止。图示如下。

在这里插入图片描述

然后是元素的删除，同样以小根堆为例，每次删除都应该删除堆中的最小元素，即根节点的元素，然后将堆的最后一个叶子节点的元素填充到根节点，此时填充到根节点的元素可能破坏堆的性质，因此需要使用第二小节中的算法来恢复根节点的堆的性质。图示如下。

在这里插入图片描述

堆的插入和删除的JAVA代码如下所示。

  1. public class HeapTry {
  4.     // 省略其它
  6.     public void insert(int[] array, int size, int i) {
  8.         array[size] = i;
  9.         int index = size;
  10.         while (array[index] < array[getParent(index)]) {
  12.             int temp = array[index];
  13.             array[index] = array[getParent(index)];
  14.             array[getParent(index)] = temp;
  15.             index = (index - 1) / 2;
  16.         }
  17.     }
  19.     public int pop(int[] array, int size) {
  21.         if (size <= 0) {
  23.             throw new IndexOutOfBoundsException();
  24.         }
  25.         int result = array[0];
  26.         array[0] = array[size - 1];
  27.         array[size - 1] = 0;
  28.         keepHeap(array, 0, size - 1);
  29.         return result;
  30.     }
  32. }

六. 实现优先级队列

本小节实现的优先级队列基于大根堆进行实现。要基于堆实现优先级队列，首先需要设计队列中的元素。先给出队列元素的JAVA代码，然后再进行说明。

  1. public class PriObject<V> {
  4.     private final V value;
  5.     private final int priority;
  6.     private final LocalDateTime dateTime;
  8.     public PriObject(V value, int priority) {
  10.         this.value = value;
  11.         this.priority = priority;
  12.         dateTime = LocalDateTime.now();
  13.     }
  15.     public V getValue() {
  17.         return value;
  18.     }
  20.     public int getPriority() {
  22.         return priority;
  23.     }
  25.     public LocalDateTime getDateTime() {
  27.         return dateTime;
  28.     }
  30.     public int compareTo(PriObject<?> priObject) {
  32.         if (priority > priObject.getPriority()) {
  34.             return 1;
  35.         } else if (priority < priObject.getPriority()) {
  37.             return -1;
  38.         } else {
  40.             return -dateTime.compareTo(priObject.getDateTime());
  41.         }
  42.     }
  44. }

队列元素类PriObject有三个属性，含义如下。

  • value表示元素的值；
  • priority表示元素的优先级，这里设定值越大优先级越高；
  • dateTime表示元素的生成时间，当向优先级队列添加value时，优先级队列会将value封装成一个PriObject对象，dateTime则表示这个元素的生成时间，用于两个元素priority相等时判断优先级，设定时间越早越优先。

队列元素类PriObject还提供了compareTo()方法用于两个元素的比较，比较规则为：priority越大越优先，如果priority相等则dateTime越小越优先。

下面看一下优先级队列PriorityQueue的字段。

  1. public class PriorityQueue<T> {
  4.     // 堆数组初始容量为16
  5.     private final int INITAIL_SIZE = 16;
  7.     // 堆数组
  8.     private PriObject<?>[] array = new PriObject<?>[INITAIL_SIZE];
  10.     // 堆元素个数
  11.     private final AtomicInteger size = new AtomicInteger(0);
  13.     // 全局锁
  14.     private final Lock lock = new ReentrantLock();
  16.     // 省略其它
  18. }

PriorityQueue的全局锁字段用于优先级队列在offer()元素和poll()元素时线程安全。

PriorityQueue内部也使用了方法来获取左右子节点和父节点的数组索引以及保持堆性质，如下所示。

  1. public class PriorityQueue<T> {
  4.     // 省略其它
  6.     private int getLeft(int i) {
  8.         return (i + 1) * 2 - 1;
  9.     }
  11.     private int getRight(int i) {
  13.         return (i + 1) * 2;
  14.     }
  16.     private int getParent(int i) {
  18.         if (i == 0) {
  20.             return 0;
  21.         }
  22.         return (i - 1) / 2;
  23.     }
  25.     private void keepHeap(int i, int size) {
  27.         int left = getLeft(i);
  28.         int rigth = getRight(i);
  30.         int max;
  32.         if (left < size) {
  34.             max = (array[i].compareTo(array[left]) > 0) ? i : left;
  35.         } else {
  37.             max = i;
  38.         }
  39.         if (rigth < size) {
  41.             max = (array[max].compareTo(array[rigth]) > 0) ? max : rigth;
  42.         }
  44.         if (i != max) {
  46.             PriObject<?> temp = array[i];
  47.             array[i] = array[max];
  48.             array[max] = temp;
  49.             keepHeap(max, size);
  50.         }
  51.     }
  53.     // 省略其它
  55. }

下面看一下PriorityQueue的offer()方法。

  1. public class PriorityQueue<T> {
  4.     // 省略其它
  6.     /**
  7.      * 添加元素到队列，每一个元素会被封装为一个{@link PriObject}对象
  8.      * 然后被添加到队列中。
  9.      * 
  10.      * @param value 队列存储的元素
  11.      * @param priority 优先级
  12.      * @return 添加成功返回true，失败返回false
  13.      */
  14.     public boolean offer(T value, int priority) {
  16.         lock.lock();
  17.         try {
  19.             PriObject<T> pObj = new PriObject<>(value, priority);
  20.             if (size.get() == array.length) {
  22.                 resize();
  23.             }
  24.             int index = size.get();
  25.             array[index] = pObj;
  26.             while (array[index].compareTo(array[getParent(index)]) > 0) {
  28.                 PriObject<?> temp = array[index];
  29.                 array[index] = array[getParent(index)];
  30.                 array[getParent(index)] = temp;
  31.                 index = getParent(index);
  32.             }
  33.             size.incrementAndGet();
  34.         } catch (Exception e) {
  36.             return false;
  37.         } finally {
  39.             lock.unlock();
  40.         }
  41.         return true;
  42.     }
  44.     private void resize() {
  46.         int oldSize = array.length;
  47.         int newSize = oldSize << 1;
  48.         array = Arrays.copyOf(array, newSize);
  49.     }
  51.     // 省略其它
  53. }

在向优先级队列添加一个元素时，如果元素个数在添加前已经等于堆数组长度，此时会触发扩容机制，并且扩容后容量为扩容前的一倍。

下面再看一下PriorityQueue的poll()方法。

  1. public class PriorityQueue<T> {
  4.     // 省略其它
  6.     public T poll() {
  8.         T value;
  9.         lock.lock();
  10.         try {
  12.             int currentSize = size.get();
  13.             if (currentSize == 0) {
  15.                 return null;
  16.             }
  17.             value = (T) array[0].getValue();
  18.             array[0] = array[currentSize - 1];
  19.             array[currentSize - 1] = null;
  20.             keepHeap(0, currentSize - 1);
  21.             size.decrementAndGet();
  22.         } catch (Exception e) {
  24.             value = null;
  25.         } finally {
  27.             lock.unlock();
  28.         }
  29.         return value;
  30.     }
  32. }

最后编写测试程序来验证实现的优先级队列的功能。测试代码如下所示。

  1. public class PriorityQueueTest {
  4.     private static final String EVENT_1 = "事件1";
  5.     private static final String EVENT_2 = "事件2";
  6.     private static final String EVENT_3 = "事件3";
  8.     @Test
  9.     public void 给定不同优先级事件_当调用offer方法_可以根据优先级正确获取元素() {
  11.         Event event1 = new Event(EVENT_1);
  12.         Event event2 = new Event(EVENT_2);
  13.         Event event3 = new Event(EVENT_3);
  14.         PriorityQueue<Event> priorityQueue = new PriorityQueue<>();
  16.         priorityQueue.offer(event1, 10);
  17.         priorityQueue.offer(event2, 20);
  18.         priorityQueue.offer(event3, 5);
  20.         assertThat(priorityQueue.poll().getEvent(), is(EVENT_2));
  21.         assertThat(priorityQueue.poll().getEvent(), is(EVENT_1));
  22.         assertThat(priorityQueue.poll().getEvent(), is(EVENT_3));
  23.     }
  25.     @Test
  26.     public void 给定相同优先级事件_当调用offer方法_可以根据添加时间正确获取元素() {
  28.         Event event1 = new Event(EVENT_1);
  29.         Event event2 = new Event(EVENT_2);
  30.         Event event3 = new Event(EVENT_3);
  31.         PriorityQueue<Event> priorityQueue = new PriorityQueue<>();
  33.         // 添加事件1，并睡眠10毫秒
  34.         priorityQueue.offer(event1, 10);
  35.         sleep10Millisecond();
  37.         // 添加事件2，并睡眠10毫秒
  38.         priorityQueue.offer(event2, 10);
  39.         sleep10Millisecond();
  41.         // 添加事件3
  42.         priorityQueue.offer(event3, 10);
  44.         assertThat(priorityQueue.poll().getEvent(), is(EVENT_1));
  45.         assertThat(priorityQueue.poll().getEvent(), is(EVENT_2));
  46.         assertThat(priorityQueue.poll().getEvent(), is(EVENT_3));
  47.     }
  49.     @Test
  50.     public void 给定17个不同优先级的事件_当调用offer方法_触发扩容() {
  52.         String eventString = "事件";
  53.         PriorityQueue<Event> priorityQueue = new PriorityQueue<>();
  55.         for (int i = 0; i < 17; i++) {
  57.             Event event = new Event(eventString + i);
  58.             priorityQueue.offer(event, i);
  59.         }
  61.         for (int i = 16; i >= 0; i--) {
  63.             assertThat(priorityQueue.poll().getEvent(), is(eventString + i));
  64.         }
  65.     }
  67.     @Test
  68.     public void 给定17个相同优先级的事件_当调用offer方法_触发扩容() {
  70.         String eventString = "事件";
  71.         PriorityQueue<Event> priorityQueue = new PriorityQueue<>();
  73.         for (int i = 0; i < 17; i++) {
  75.             Event event = new Event(eventString + i);
  76.             priorityQueue.offer(event, 10);
  77.             sleep10Millisecond();
  78.         }
  80.         for (int i = 0; i < 17; i++) {
  82.             assertThat(priorityQueue.poll().getEvent(), is(eventString + i));
  83.         }
  84.     }
  86.     private void sleep10Millisecond() {
  88.         try {
  90.             Thread.sleep(10);
  91.         } catch (InterruptedException e) {
  93.             System.out.println(e.getMessage());
  94.         }
  95.     }
  97.     private static class Event {
  99.         private final String event;
  101.         public Event(String event) {
  103.             this.event = event;
  104.         }
  106.         public String getEvent() {
  108.             return event;
  109.         }
  110.     }
  112. }

测试了四个场景，分别是：priority不同，priority相同，触发扩容时priority不同和触发扩容时priority相同这四种场景下的优先级队列的功能实现。执行结果如下。

在这里插入图片描述

总结

堆是一颗完全二叉树，并且根据父节点总是大于等于子节点或者父节点总是小于等于子节点可将堆划分为大根堆和小根堆。堆中元素可以由一个数组来表示，并且可以根据某个节点在数组中的索引计算得到该节点的左右子节点和父节点在数组中的索引。基于堆可以实现排序算法，通常，大根堆实现升序排序，小根堆实现降序排序。基于堆还可以实现优先级队列，并且优先级队列的元素存储在一个堆数组中，堆数组在容量满时会进行扩容，因此可以将优先级队列看作是一个无界队列。

发表评论

表情：
评论列表 （有 0 条评论，174人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java优先级队列-堆

    本文章主要讲解了基二叉树之后的知识点堆，讲解了什么是堆，以及堆的应用-优先级队列的使用，用堆来解决TopK问题，作者在最后为各位读者准备了习题以及讲解答案，希望对大家有帮...

    古城微笑少年丶古城微笑少年丶/ 0 赞/ 210 阅读

    相关 优先级队列（堆）

    优先级队列 概念 > 我们知道，队列是一种先进先出的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用

    灰太狼灰太狼/ 0 赞/ 178 阅读