数据结构基础加强之最小堆的实现与堆排序

 数据结构基础加强之最小堆的实现与堆排序

二叉堆的形式：

最小堆：根结点的值是所有堆结点中最小者，并且每个结点的值比其孩子结点小。
最大堆：根结点的值是所有堆结点中最大者，并且每个结点的值比其孩子结点大。

最小堆通常都是一棵完全二叉树，可以用数组来存储最小堆的值。

堆中父结点与子结点 的关系：

heap[father * 2] = heap[leftChild];  heap[father * 2 + 1] = heap[rightChild];

最大堆与最小堆基本做法基本一致，只要把实现代码中的小于变大于，大于变小于即可。

最小堆的初始化：依次将节点加入堆数组中，每次进入新的结点加到堆数组的尾部，依次与父结点相比较，如果小于父结点则交换二者的位置。

	//添加元素
	public void add(int item){
		size++;
		heap[size] = item;
		int curr = size;
		while (heap[curr] < heap[getFather(curr)]) {
			swap(curr,getFather(curr));
			curr = getFather(curr);
		}
	}

最小堆的调整：一处最小堆的根节点之后，需要调整堆数组使之成为一个新的堆。

可以采用以下方式来调整堆：将堆数组最后一个元素放到堆数组的首部，依次与左右子结点比较，把较小的值与根节点交换，然后递归，直至当前节点是叶子节点为止。

	//元素下移调整
	public void pushDown(int pos){
		int smallChild;
		while (!isLeaf(pos)) {
			smallChild = getLeftChild(pos);
			//在父节点知道的情况下，左节点不会出现越界情况，右节点可能越界
			if (smallChild <= size) { 
				if (getRightChild(pos) <= size && heap[smallChild] > heap[smallChild + 1]) {
					smallChild++;
				}
				if (heap[pos] > heap[smallChild]) {
					swap(pos,smallChild);
					pos = smallChild;
				}else {
					return;
				}
			}else {
				return;
			}
		}
	}

堆排序的实现：

利用建立的堆实现堆排序比较简单。将数组中的元素依次加入最小堆中，每次取出堆数组的第一个元素，即最小值放到待排序数组的首部。每次取出堆数组第一个元素后，堆数组会自己调整，让它继续是一个最小堆。依次取出最数组的中的第一个元素，依次放入待排序数组中，直至堆数组为空，此时待排序数组是有序的。

堆排序实现代码：

import heap.Heap;

public class HeapSort {

	public static void main(String[] args) {

		int[] array = { 1, 9, 6, 8, 7, 3, 4, 2, 0 };
		solution(array);
		for (int i : array) {
			System.out.print(i + " ");
		}
	}

	private static void solution(int[] array) {

		Heap heap = new Heap(10);
		for (int i : array) {
			heap.add(i);
		}
		for (int i = 0;i < array.length;i++) {
			array[i] = heap.delete();
		}
	}

}

最小堆的实现代码：

public class Heap {

	private int[] heap;
	private int size;//当前节点数
	@SuppressWarnings("unused")
	private int max; //最大节点数
	
	//使用数组存储堆元素  根节点位于数组下表为1的元素
	public Heap(int max){
		this.max = max;
		heap = new int[max];
		size = 0;
		heap[0] = Integer.MIN_VALUE;
	}
	//获得父节点的位置
	public int getFather(int index){
		return index / 2;
	}
	//获得左子节点的位置
	public int getLeftChild(int index){
		return index * 2;
	}
	//获得右子节点的位置
	public int getRightChild(int index){
		return index * 2 + 1;
	}
	//判断节点是否为根节点
	public boolean isLeaf(int index){
		if (index > size / 2 && index < size) {
			return true;
		}else{
			return false;
		}
	}
	//判断堆是否为空
	public boolean isEmpty(){
		if (size == 0) {
			return true;
		}else{
			return false;
		}
	}
	//元素交换
	public void swap(int pos1,int pos2){
		int temp = heap[pos1];
		heap[pos1] = heap[pos2];
		heap[pos2] = temp;
	}
	//打印所有节点
	public void print(){
		for (int i = 1;i <= size;i++) {
			System.out.print(heap[i] + " ");
		}
	}
	//添加元素
	public void add(int item){
		size++;
		heap[size] = item;
		int curr = size;
		while (heap[curr] < heap[getFather(curr)]) {
			swap(curr,getFather(curr));
			curr = getFather(curr);
		}
	}
	//删除并返回根节点
	public int delete(){
		int firstItem = heap[1];
		swap(1, size);
		size--;
		if (size != 1) {
			pushDown(1);
		}
		return firstItem;
	}
	//元素下移调整
	public void pushDown(int pos){
		int smallChild;
		while (!isLeaf(pos)) {
			smallChild = getLeftChild(pos);
			//在父节点知道的情况下，左节点不会出现越界情况，右节点可能越界
			if (smallChild <= size) { 
				if (getRightChild(pos) <= size && heap[smallChild] > heap[smallChild + 1]) {
					smallChild++;
				}
				if (heap[pos] > heap[smallChild]) {
					swap(pos,smallChild);
					pos = smallChild;
				}else {
					return;
				}
			}else {
				return;
			}
		}
	}
}

具体代码可以参考：https://github.com/Li-JY/algorithm-and-datastructure/tree/master/src/heap