数据结构——二叉堆(Java代码实现)

1.堆

1.1定义

堆（Heap）是一种树状的数据结构，通常是一个可以被看做一棵树的数组对象。常见的堆实现有

• 二叉堆（Binary Heap，完全二叉堆）
• 多叉堆（D-heap、D-ary Heap）
• 索引堆（Index Heap）
• 二项堆（Binomial Heap）
• 斐波那契堆（Fibonacci Heap）
• 左倾堆（Leftist Heap，左式堆）
• 斜堆（Skew Heap）

1.2性质

堆的一个重要性质：任意节点的值总是 ≥（ ≤ ）子节点的值

• 如果任意节点的值总是 ≥ 子节点的值，称为：最大堆、大根堆、大顶堆
• 如果任意节点的值总是 ≤ 子节点的值，称为：最小堆、小根堆、小顶堆
  
  以最大堆举例，第一层的72>第二层的68和50，第二层左侧的68>第三层的43和38，右侧的50大于第三层的47和21，第三层左侧的43>第四层的14和40，右侧的38>第四层的3。

2.二叉堆

2.1定义

二叉堆的逻辑结构就是一棵完全二叉树，所以也叫完全二叉堆，鉴于完全二叉树的一些特性，二叉堆的底层（物理结构）一般用数组实现即可

2.2性质

索引 i 的规律（ n 是元素数量）

• 如果 i = 0 ，它是根节点
• 如果 i > 0 ，它的父节点的索引为 floor( (i – 1) / 2 )
• 如果 2i + 1 ≤ n – 1，它的左子节点的索引为 2i + 1
• 如果 2i + 1 > n – 1 ，它无左子节点
• 如果 2i + 2 ≤ n – 1 ，它的右子节点的索引为 2i + 2
• 如果 2i + 2 > n – 1 ，它无右子节点

2.3实现（大顶堆）

2.3.1基本设计

• int size(); // 元素的数量
• boolean isEmpty(); // 是否为空
• void clear(); // 清空
• void add(E element); // 添加元素
• E get(); // 获得堆顶元素
• E remove(); // 删除堆顶元素
• E replace(E element); // 删除堆顶元素的同时插入一个新元素
• void heapify() ; 批量建堆
• void siftDown(int index);让index位置的元素下滤
• void siftUp(int index);让index位置的元素上滤
• void ensureCapacity(int capacity);扩容

private void ensureCapacity(int capacity) {
    
    
		int oldCapacity = elements.length;
		if (oldCapacity >= capacity) {
    
    
			return;
		}
		
		// 新容量为旧容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		E[] newElements = (E[]) new Object[newCapacity];
		for (int i = 0; i < size; i++) {
    
    
			newElements[i] = elements[i];
		}
		elements = newElements;
	}
	

• void emptyCheck()；判断堆中元素是否为空

private void emptyCheck() {
    
    
		if (size == 0) {
    
    
			throw new IndexOutOfBoundsException("Heap is empty");
		}
	}

• void elementNotNullCheck(E element)；判断传入的元素是否为空；

	private void elementNotNullCheck(E element) {
    
    
		if (element == null) {
    
    
			throw new IllegalArgumentException("element must not be null");
		}
	}

2.3.2 添加

2.3.2.1上滤

添加元素80后，循环执行以下操作（图中的 80 简称为 node） ，如果 node ＞ 父节点 与父节点交换位置
，如果 node ≤ 父节点，或者 node 没有父节点，则此处满足堆的定义，退出循环，这个过程，叫做上滤（Sift Up）。

2.3.2.2过程分析

版本一

如上图，

1. 添加元素80后，执行siftUp（index）进入循环，与父节点43进行比较，80>43即node>父节点，与父元素交换位置，结果如图二所示。
2. 再次进入循环，与父节点68进行比较，80>68。与父结点互换位置，结果如图三。
3. 同样的操作执行下一步，结果如图四。
4. 再次进入循环，此时80节点的索引为1，则父节点索引为0，跳出循环。
   代码如下：

private void siftUp(int index) {
    
    
		E e = elements[index];
		while (index > 0) {
    
    
			int pindex = (index - 1) >> 1;
			E p = elements[pindex];
			if (compare(e, p) <= 0) return;

			// 交换index、pindex位置的内容
			E tmp = elements[index];
			elements[index] = elements[pindex];
			elements[pindex] = tmp;

			// 重新赋值index
			index = pindex;
		}
	}

优化版本

一般交换位置需要3行代码，可以进一步优化，将新添加节点备份，确定最终位置才摆放上去。

如上图，如果满足交换条件，用父节点覆盖原来的子节点，而父节点不变，依次进行，直至最后将添加元素进行更换。 仅从交换位置的代码角度看可以由大概的 3 * O(logn) 优化到 1 * O(logn) + 1。
代码实现：

@Override
public void add(E element) {
    
    
	elementNotNullCheck(element);
	ensureCapacity(size + 1);
	elements[size++] = element;
	siftUp(size - 1);
}

private void siftUp(int index) {
    
    
		E element = elements[index];
		while (index > 0) {
    
    
			int parentIndex = (index - 1) >> 1;
			E parent = elements[parentIndex];
			if (compare(element, parent) <= 0) {
    
    
				break;
			}

			// 将父元素存储在index位置
			elements[index] = parent;

			// 重新赋值index
			index = parentIndex;
		}
		elements[index] = element;
	}

2.3.3删除

2.3.3.1下滤

1. 用最后一个节点覆盖根节点
2. 删除最后一个节点
3. 循环执行以下操作（图中的 43 简称为 node）
   如果 node < 最大的子节点 与最大的子节点交换位置
   如果 node ≥ 最大的子节点， 或者 node 没有子节点 退出循环

这个过程，叫做下滤（Sift Down），时间复杂度：O(logn)，同样的，交换位置的操作可以像添加那样进行优化

2.3.3.2过程分析

1. 如上图，将根节点的值变为尾结点的值，删除尾结点，执行siftDown（0），进入循环，先判断根节点的左右节点哪一个大，然后让大的子节点和父节点进行比较，43<72,则将该子节点与父节点进行互换，如图三。
2. 再次进入循环，43与68进行比较，互换，结果如图四。
3. 再次进入循环，43>14,跳出循环。

下面的代码为优化过的，具体过程与添加相似：

@Override
public E remove() {
    
    
	emptyCheck();
	
	int lastIndex = --size;
	E root = elements[0];
	elements[0] = elements[lastIndex];
	elements[lastIndex] = null;
	
	siftDown(0);
	return root;
}


private void siftDown(int index) {
    
    
	E element = elements[index];
	int half = size >> 1;
	// 第一个叶子节点的索引 == 非叶子节点的数量
	// index < 第一个叶子节点的索引
	// 必须保证index位置是非叶子节点
	while (index < half) {
    
     
		// index的节点有2种情况
		// 1.只有左子节点
		// 2.同时有左右子节点
		
		// 默认为左子节点跟它进行比较
		int childIndex = (index << 1) + 1;
		E child = elements[childIndex];
		
		// 右子节点
		int rightIndex = childIndex + 1;
		
		// 选出左右子节点最大的那个
		if (rightIndex < size && compare(elements[rightIndex], child) > 0) {
    
    
			child = elements[childIndex = rightIndex];
		}
		
		if (compare(element, child) >= 0) {
    
    
			break;
		}

		// 将子节点存放到index位置
		elements[index] = child;
		// 重新设置index
		index = childIndex;
	}
	elements[index] = element;
}

2.3.4替换（replace）

@Override
public E replace(E element) {
    
    
	elementNotNullCheck(element);
	
	E root = null;
	if (size == 0) {
    
    
		elements[0] = element;
		size++;
	} else {
    
    
		root = elements[0];
		elements[0] = element;
		siftDown(0);
	}
	return root;
}

2.4批量建堆（Heapify）

批量建堆（Heapify）：就是将已经存在n个元素的数组批量添加至堆中，而不是遍历数组一个一个将元素添加至堆中。

遍历数组一个一个添加元素至堆中，时间复杂度为O(nlogn)，而使用批量建堆，时间复杂度最低可以降为O(n)。

2.4.1自上而下的上滤

自上而下的上滤类似于从第2个元素开始依次添加，本质为添加。

代码如下：

	for (int i = 1; i < size; i++) {
    
    
		siftUp(i);
	}

2.4.2自下而上的下滤

自下而上的下滤类似于从最后一个非叶子节点开始往前删除，本质为删除。

代码如下：

for (int i = (size >> 1) - 1; i >= 0; i--）{
    
    
	siftDown(i);
}

2.4.3效率对比

• 所有节点的深度之和
  仅仅是叶子节点，就有近 n/2 个，而且每一个叶子节点的深度都是 O(logn) 级别的，因此，在叶子节点这一块，就达到了 O(nlogn) 级别。O(nlogn) 的时间复杂度足以利用排序算法对所有节点进行全排序

推导公式为：

2.4.4 批量建堆

public BinaryHeap(E[] elements, Comparator<E> comparator)  {
    
    
	super(comparator);
	
	if (elements == null || elements.length == 0) {
    
    
		this.elements = (E[]) new Object[DEFAULT_CAPACITY];
	} else {
    
    
		size = elements.length;
		int capacity = Math.max(elements.length, DEFAULT_CAPACITY);
		this.elements = (E[]) new Object[capacity];
		for (int i = 0; i < elements.length; i++) {
    
    
			this.elements[i] = elements[i];
		}
		heapify();
	}
}

private void heapify() {
    
    
	// 自上而下的上滤
//		for (int i = 1; i < size; i++) {
    
    
//			siftUp(i);
//		}
	
	// 自下而上的下滤
	for (int i = (size >> 1) - 1; i >= 0; i--) {
    
    
		siftDown(i);
	}
}

2.4.5构建小顶堆

public static void test3() {
    
    
	Integer[] data = {
    
    88, 44, 53, 41, 16, 6, 70, 18, 85, 98, 81, 23, 36, 43, 37};
	BinaryHeap<Integer> heap = new BinaryHeap<>(data, new Comparator<Integer>() {
    
    
		@Override
		public int compare(Integer o1, Integer o2) {
    
    
			return o2 - o1;
		}
	});
	BinaryTrees.println(heap);
}

2.5Top K问题

2.5.1问题描述

从n个整数中，找出最大的前k个数（k远远小于n）

2.5.2解题思路

• 如果使用排序算法进行全排序，需要O(nlogn)的时间复杂度（快速排序）
• 如果使用二叉堆来解决，可以使用 O(nlogk) 的时间复杂度来解决

查找步骤：

• 新建一个小顶堆

• 扫描n个整数,先将遍历到的前k个数放入堆中,从第k+1个数开始，如果大于堆顶元素，就使用replace操作（删除堆顶元素，将第k+1个数添加到堆中）

• 扫描完毕后，堆中剩下的就是最大的前k个数

如果是找出最小的前k个数呢？用大顶堆，如果小于堆顶元素，就使用replace操作。

2.5.3 代码实现

	public static void test4() {
    
    
		// 新建一个小顶堆
		BinaryHeap<Integer> heap = new BinaryHeap<>(new Comparator<Integer>() {
    
    
			@Override
			public int compare(Integer o1, Integer o2) {
    
    
				return o2 - o1;
			}
		});
		
		// 找出最大的前k个数
		int k = 3;
		Integer[] data = {
    
    51, 30, 39, 92, 74, 25, 16, 93, 
				91, 19, 54, 47, 73, 62, 76, 63, 35, 18, 
				90, 6, 65, 49, 3, 26, 61, 21, 48};
		for (int i = 0; i < data.length; i++) {
    
    
			if (heap.size() < k) {
    
     // 前k个数添加到小顶堆
				heap.add(data[i]); // logk
			} else if (data[i] > heap.get()) {
    
     // 如果是第k + 1个数，并且大于堆顶元素
				heap.replace(data[i]); // logk
			}
		}
		// O(nlogk)
		BinaryTrees.println(heap);
	}

3.优先级队列（Priority Queue）

3.1定义

优先级队列则是按照 优先级高低 进行出队，比如将优先级最高的元素作为队头优先出队，底层的原理就是 二叉堆 的操作，可以通过 Comparator 或 Comparable 去自定义优先级高低

3.2实现

	package queue;
	
	import heap.BinaryHeap;
	
	import java.util.Comparator;
	
	public class PriorityQueue<E> {
    
    
		private BinaryHeap<E> heap;
		
		public PriorityQueue(Comparator<E> comparator) {
    
    
			heap = new BinaryHeap<>(comparator);
		}
		
		public PriorityQueue() {
    
    
			this(null);
		}
		
		public int size() {
    
    
			return heap.size();
		}
	
		public boolean isEmpty() {
    
    
			return heap.isEmpty();
		}
		
		public void clear() {
    
    
			heap.clear();
		}
	
		public void enQueue(E element) {
    
    
			heap.add(element);
		}
	
		public E deQueue() {
    
    
			return heap.remove();
		}
	
		public E front() {
    
    
			return heap.get();
		}
	}
	
	public class Person implements Comparable<Person> {
    
    
		private String name;
		private int boneBreak;
		public Person(String name, int boneBreak) {
    
    
			this.name = name;
			this.boneBreak = boneBreak;
		}
		
		@Override
		public int compareTo(Person person) {
    
    
			return this.boneBreak - person.boneBreak;
		}
	
		@Override
		public String toString() {
    
    
			return "Person [name=" + name + ", boneBreak=" + boneBreak + "]";
		}
	}
	
	import queue.PriorityQueue;
	
	public class Main {
    
    
	
		public static void main(String[] args) {
    
    
			PriorityQueue<Person> queue = new PriorityQueue<>();
			queue.enQueue(new Person("Jack", 2));
			queue.enQueue(new Person("Rose", 10));
			queue.enQueue(new Person("Jake", 5));
			queue.enQueue(new Person("James", 15));
			
			while (!queue.isEmpty()) {
    
    
				System.out.println(queue.deQueue());
			}
		}
	}

输出结果：