一. 堆是什么
堆树的定义如下:
(1)堆树是一颗完全二叉树;
完全二叉树:除了最后一层,其他层的节点个数都是最大值,即 2^N,N为层数,根节点为0;且最后一层自左向右的节点是连续的
(2)堆树中某个节点的值总是不大于或不小于其孩子节点的值;
(3)堆树中每个节点的子树都是堆树。
当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。
当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。
堆可以用数组来表示,因为堆是完全二叉树,而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2,而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置,是为了更清晰地描述节点的位置关系。
package com.hong.heap;
import com.hong.arrays.Array;
public class MaxHeap<E extends Comparable<E>> {
private Array<E> data;
public MaxHeap(int capacity) {
data = new Array<>(capacity);
}
public MaxHeap() {
data = new Array<>();
}
/**
* 将任意数组转化成堆的形式 heapify
* 两种方式:
* 1.向堆中一个一个的添加元素,时间复杂度O(NlongN) ,N为元素个数
* 2.从第一个非叶子节点开始,进行siftDown,时间复杂度 O(N)
*
* @param arr
*/
public MaxHeap(E[] arr) {
/**
* 由最后一个元素的索引推导出第一个非叶子节点的索引,然后开始向前一个一个的进行siftDown()
* 这样,就不需要像第一种方式一样,需要遍历每个元素
*/
data = new Array<>(arr);
for (int i = parent(arr.length - 1); i >= 0; i--) {
siftDown(i);
}
}
/**
* 返回堆中元素的个数
*
* @return
*/
public int size() {
return data.getSize();
}
public boolean isEmpty() {
return data.isEmpty();
}
/**
* 返回完全二叉树的数组表示中,index索引位置的元素的父元素在数组中的索引
*
* @param index
* @return
*/
private int parent(int index) {
if (index == 0) {
throw new IllegalArgumentException("index-0 doesn't have parent.");
}
return (index - 1) / 2;
}
/**
* 返回完全二叉树的数组表示中,index索引位置的元素的左孩子在数组中的索引
*
* @param index
* @return
*/
private int leftChild(int index) {
return index * 2 + 1;
}
/**
* 返回完全二叉树的数组表示中,index索引位置的元素的右孩子在数组中的索引
*
* @param index
* @return
*/
private int rightChild(int index) {
return index * 2 + 2;
}
/**
* 向堆中添加元素
* 在堆的最后增加一个结点,然后沿这堆树上升.
* 将新元素放到数组末尾,然后上浮到合适的位置。
* @param e
*/
public void add(E e) {
//尾插法
data.addLast(e);
siftUp(data.getSize() - 1);
}
/**
* 向上筛选,找到新插入元素的正确位置
* 在堆中,当一个节点比父节点大,那么需要交换这个两个节点。
* 交换后还可能比它新的父节点大,因此需要不断地进行比较和交换操作,把这种操作称为上浮(ShiftUp)。
*
* @param k
*/
private void siftUp(int k) {
/* while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
data.swap(k, parent(k));
k = parent(k);
}*/
/**
* siftUp优化:
* 在上面的代码中,每次比较当前节点和其父节点的值,符合条件则交换
* 这中间的交换过程是可以优化的,我们的目的是最终将k位置的元素与沿着
* 其父节点的路径上找到第一个比k位置元素大的节点时或者到达根节点时则停止比较.
* 参考Java的PriorityQueue的实现。
*/
E cur = data.get(k);
while (k > 0){
int parentIndex = parent(k);
E parent = data.get(parentIndex);
if (cur.compareTo(parent) <= 0){
break;
}
data.set(k,parent);
k = parentIndex;
}
data.set(k,cur);
}
/**
* 查看堆中的最大元素
*
* @return
*/
public E findMax() {
if (data.getSize() == 0) {
throw new IllegalArgumentException("Can not findMax when heap is empty.");
}
return data.get(0);
}
/**
* 取出堆中的最大元素
*
* @return
*/
public E extractMax() {
E max = findMax();
//将最后一个元素先放到第一个位置,然后数据下沉筛选,找到在堆中的正确位置
data.swap(0, data.getSize() - 1);
data.removeLast();
siftDown(0);
return max;
}
/**
* 向下调整k位置的元素
* 当前k位置的元素与 k位置元素的左右孩子中较大的值比较,
* 如果 > 较大值,则说明元素已经在正确的位置了,终止循环;
* 否则互换,从较大值位置继续上面的逻辑
*
* 类似地,当一个节点比子节点来得小,也需要不断地向下进行比较和交换操作,把这种操作称为下沉(Shift Down)。
* 一个节点如果有两个子节点,应当与两个子节点中最大那么节点进行交换。
* @param k
*/
private void siftDown(int k) {
// 当前节点是非叶子节点
while (leftChild(k) < data.getSize()) {
int j = leftChild(k);
// 如果也存在右孩子,则取出左右孩子较大值索引
if ((j + 1) < data.getSize() &&
data.get(j + 1).compareTo(data.get(j)) > 0) {
j = j + 1;
}
// data[j] 是 leftChild 和 rightChild 中的最大值
if (data.get(k).compareTo(data.get(j)) >= 0) {
break;
}
data.swap(j, k);
k = j;
}
}
/**
* 从堆中取出最大元素,替换成元素e
*
* @param e
* @return
*/
public E replace(E e) {
E ret = findMax();
data.set(0, e);
siftDown(0);
return ret;
}
}
package com.hong.arrays;
/**
* @author wanghong
* @date 2019/04/06 17:04
* 封装自定义数组
**/
public class Array<T> {
private T[] data;
private int size;
public Array() {
this(10);
}
public Array(int capacity) {
data = (T[]) new Object[capacity];
size = 0;
}
public Array(T[] arr) {
data = (T[]) new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
size = arr.length;
}
public int getCapacity() {
return data.length;
}
// 获取数组中的元素个数
public int getSize() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
/**
* 头插法
*
* @param t
*/
public void addFirst(T t) {
add(0, t);
}
/**
* 尾插法
*
* @param t
*/
public void addLast(T t) {
add(size, t);
}
/**
* 向index索引处插入新元素
*
* @param index
* @param t
*/
public void add(int index, T t) {
// 判断要插入的索引是否越界,即要插入的索引位置在[0,size]的区间内
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed,Require index > 0 and index <= size");
}
// 判断当前数组容量是否已满,满了自动扩容
if (size == data.length) {
// throw new IllegalArgumentException("Add failed,Array is full");
resize(2 * data.length);
}
// 将 索引 >= index 位置的元素依次向后挪一位,腾出index的位置放入新元素,这里从最后一个元素开始挪动
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
data[index] = t;
size++;
}
/**
* 获取index索引处的元素
*
* @param index
* @return
*/
public T get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get failed. Index is illegal.");
}
return data[index];
}
public T getLast() {
return get(size - 1);
}
public T getFirst() {
return get(0);
}
/**
* 修改index索引位置的元素为t
*
* @param index
* @param t
*/
public void set(int index, T t) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Set failed. Index is illegal.");
}
data[index] = t;
}
/**
* 判断数组中是否包含元素t
*
* @param t
* @return
*/
public boolean contains(T t) {
for (int i = 0; i < size; i++) {
if (data[i].equals(t)) {
return true;
}
}
return false;
}
/**
* 查找数组中元素t的索引,无则返回-1
*
* @param t
* @return
*/
public int find(T t) {
for (int i = 0; i < size; i++) {
if (data[i].equals(t)) {
return i;
}
}
return -1;
}
/**
* 删除第一个元素
*
* @return
*/
public T removeFirst() {
return remove(0);
}
/**
* 删除最后一个元素
*
* @return
*/
public T removeLast() {
return remove(size - 1);
}
/**
* 从数组中删除指定的元素
*
* @param t
*/
public void removeElement(T t) {
int index = find(t);
if (index != -1) {
remove(index);
}
}
/**
* 从数组中删除index位置处的元素并返回被删除的元素
*
* @param index
* @return
*/
public T remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed. Index is illegal.");
}
T t = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
data[size] = null; // loitering objects != memory leak
/**
* 删除元素后,如果剩下的容量到了一半则缩容
* 为了防止复杂度震荡,即出现这样的操作:
* addLast -> 超过data.length -> resize -> removeLast -> resize
* 反复几次,会造成复杂度突然上升,性能下降
* 解决方案:Lazy
*/
// if (size == data.length / 2) {
if (size == data.length / 4 && data.length / 2 != 0) {
resize(data.length / 2);
}
return t;
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("Array:size = %d,capacity = %d\n", size, data.length));
res.append("[");
for (int i = 0; i < size; i++) {
res.append(data[i]);
if (i != size - 1) {
res.append(",");
}
}
res.append("]");
return res.toString();
}
/**
* 将数组扩容为newCapacity大小
*
* @param newCapacity
*/
private void resize(int newCapacity) {
T[] newData = (T[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
/**
* 互换i,j位置的两个元素
*
* @param i
* @param j
*/
public void swap(int i, int j) {
if (i < 0 || i >= size || j < 0 || j >= size)
throw new IllegalArgumentException("Index is illegal.");
T t = data[i];
data[i] = data[j];
data[j] = t;
}
}
二. 堆排序
由于堆可以很容易得到最大的元素并删除它,不断地进行这种操作可以得到一个递减序列。如果把最大元素和当前堆中数组的最后一个元素交换位置,并且不删除它,那么就可以得到一个从尾到头的递减序列,从正向来看就是一个递增序列。因此很容易使用堆来进行排序。并且堆排序是原地排序,不占用额外空间。
- 版本一:原地堆排序
package com.hong.heap;
import com.hong.sort.SortTestHelper;
/**
* @author wanghong
* @date 2019/11/24 22:18
* 不使用一个额外的最大堆, 直接在原数组上进行原地的堆排序
**/
public class HeapSort {
// 我们的算法类不允许产生任何实例
private HeapSort(){}
public static void sort(Integer[] arr){
int n = arr.length;
// 注意,此时我们的堆是从0开始索引的
// 从(最后一个元素的索引-1)/2开始,即第一个 non-leaf node
// 最后一个元素的索引 = n-1
for( int i = (n-1-1)/2 ; i >= 0 ; i -- ){
shiftDown2(arr, n, i);
}
for( int i = n-1; i > 0 ; i-- ){
swap( arr, 0, i);
shiftDown2(arr, i, 0);
}
}
// 交换堆中索引为i和j的两个元素
private static void swap(Object[] arr, int i, int j){
Object t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
// 原始的shiftDown过程
private static void shiftDown(Comparable[] arr, int n, int k){
while( 2*k+1 < n ){
int j = 2*k+1;
if( j+1 < n && arr[j+1].compareTo(arr[j]) > 0 )
j += 1;
if( arr[k].compareTo(arr[j]) >= 0 )break;
swap( arr, k, j);
k = j;
}
}
// 优化的shiftDown过程, 使用赋值的方式取代不断的swap,
// 该优化思想和我们之前对插入排序进行优化的思路是一致的
private static void shiftDown2(Comparable[] arr, int n, int k){
Comparable e = arr[k];
while( 2*k+1 < n ){
int j = 2*k+1;
if( j+1 < n && arr[j+1].compareTo(arr[j]) > 0 ){
j += 1;
}
if( e.compareTo(arr[j]) >= 0 ){
break;
}
arr[k] = arr[j];
k = j;
}
arr[k] = e;
}
// 测试 HeapSort
public static void main(String[] args) {
int N = 1000000;
Integer[] arr = SortTestHelper.generateRandomArray2(N, 0, 100000);
SortTestHelper.testSort2("com.hong.heap.HeapSort", arr);
}
}
- 版本二
package com.hong.heap;
import com.hong.sort.SortTestHelper;
/**
* @author wanghong
* @date 2019/11/24 21:50
* 基础堆排序和Heapify(堆化)
**/
public class HeapSort1 {
// 对整个arr数组使用HeapSort1排序
// HeapSort1, 将所有的元素依次添加到堆中, 在将所有元素从堆中依次取出来, 即完成了排序
// 无论是创建堆的过程, 还是从堆中依次取出元素的过程, 时间复杂度均为O(nlogn)
// 整个堆排序的整体时间复杂度为O(nlogn)
public static void sort(int[] arr){
int n = arr.length;
MaxHeap<Integer> maxHeap = new MaxHeap<>(n);
for (int i = 0;i < n;i++){
maxHeap.add(arr[i]);
}
for (int i = n-1;i>=0;i--){
arr[i] = maxHeap.extractMax();
}
}
// 测试 HeapSort1
public static void main(String[] args) {
int N = 1000000;
int[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
SortTestHelper.testSort("com.hong.heap.HeapSort1", arr);
}
}
- 版本三
package com.hong.heap;
import com.hong.sort.SortTestHelper;
/**
* @author wanghong
* @date 2019/11/24 21:57
* 优化的堆排序
**/
public class HeapSort2 {
// 对整个arr数组使用HeapSort2排序
// HeapSort2, 借助我们的heapify过程创建堆
// 此时, 创建堆的过程时间复杂度为O(n), 将所有元素依次从堆中取出来, 时间复杂度为O(nlogn)
// 堆排序的总体时间复杂度依然是O(nlogn), 但是比HeapSort1性能更优, 因为创建堆的性能更优
public static void sort(Integer[] arr){
MaxHeap<Integer> maxHeap = new MaxHeap<>(arr);
for (int i = arr.length-1;i >= 0;i--){
arr[i] = maxHeap.extractMax();
}
}
// 测试 HeapSort2
public static void main(String[] args) {
int N = 1000000;
Integer[] arr = SortTestHelper.generateRandomArray2(N, 0, 100000);
SortTestHelper.testSort2("com.hong.heap.HeapSort2", arr);
}
}
三. 堆排序的应用——Top K问题
在N个元素中选出前M个元素
M远小于N
排序: NlongN
优先队列 NlogM 维护当前看到的前M个元素
四. 排序算法总结
/ 可以通过⾃自定义⽐比较函数,让排序算法不不存在稳定性的问题。
boolean operator<(const Student& otherStudent){
return score != otherStudent.score ?
score > otherStudent.score :
name < otherStudent.name;
}
![](https://github.com/frank-lam/2019_campus_apply/raw/master/notes/pics/sort_algorithm_analyze.png)