堆排序算法及实现

堆排序分为小根堆（最小堆）和大根堆（最大堆）两种，前一种是升序排列，后一种是降序排列。堆排序与快速排序及归并排序一样，时间复杂度都是O(nlogn)，属于比较常用的排序方法。

堆排序是利用了二叉树的特性，二叉堆类似于完全二叉树，小（大）根堆的每一个非叶子节点的值都小于（大于）或等于其左右孩子的值。

堆的存储一般是用数组的形式，i结点的父结点下标是（i-1）/2，左孩子结点下标是2*i+1，右孩子结点下标是2*i+2。数组下标从零开始。

堆排序的过程是一个建堆、删除根和不断调整堆的过程，当然堆的操作还包括插入元素。

整个过程实现如下：

public class HeapSort {
	/*
	 * 方法1： 以需要调整的结点的左孩子为基准，每次判断交换后的非叶子结点
	 */
	private void adjustHeapNoRec(int[] a, int i, int n) {
		int tmp;
		tmp = a[i];
		int j = 2*i + 1;
		while(j < n) {
			if(j+1 < n && a[j+1] < a[j]) {
				j ++;
			}
			
			if(a[j] >= tmp) break;
			
			a[i] = a[j];
			i = j;
			j = 2*i + 1;
		}
		a[i] = tmp;
	}
	/*
	 * 方法1的递归的处理方法
	 */
	private void adjustHeapRec(int[] a, int i, int end) {
		if(i >= end) return;
		int tmp = a[i];
		int j = 2*i + 1;
		if(j >= end) return;
		if(j + 1 < end && a[j+1] < a[j])
			j ++;
		if(a[j] > a[i]) return;
		a[i] = a[j];
		i = j;
		a[i] = tmp;
		adjustHeapRec(a, i, end);
	}
	/*
	 * 方法2： 以需要调整的结点为基准，判断其左右孩子，调整到最后一个非叶子节点即可。
	 */
	private void ajustHeapNonRec(int[] a, int i, int n) {
		int min = i;
		while(i < (n-1)/2) {
			int left = 2*i+1;
			int right = 2*i+2;
			
			if(left < n && a[left] < a[min])
				min = left;
			if(right < n && a[right] < a[min])
				min = right;
			
			if(min != i) {
				int tmp = a[i];
				a[i] = a[min];
				a[min] = tmp;
				i = min;
			}
		}
	}
	/*
	 * 方法2的递归处理方法
	 */
	private void adjustHeapRecur(int[] a, int i, int n) {
		if(i >= (n-1)/2) return;
		int min = i;
		int left = 2*i+1;
		int right = 2*i+2;
		if(left < n && a[left] < a[min])
			min = left;
		if(right < n && a[right] < a[min]) 
			min = right;
		if(min != i) {
			int tmp = a[i];
			a[i] = a[min];
			a[min] = tmp;
			adjustHeapRecur(a, min, n);
		}
	}
	/*
	 * 建堆的过程就是从最后一个非叶子结点开始，不断调整堆的过程。
	 */
	private void buildHeap(int[] a, int start, int end, int n) {
		int mid = (start + end - 1) >> 1;
		for(int i = mid; i >= 0; i --) {
//			adjustHeapRec(a, i, n);
//			ajustHeapNonRec(a,i,n);
			adjustHeapRecur(a,i,n);
		}
	}
	/*
	 * 删除堆：每次删除时，将根与当前堆的最后一个元素交换。
	 */
	private void deleteHeap(int[] a, int n) {
		int j = n - 1;
		while(j > 0) {
			int tmp = a[0];
			a[0] = a[j];
			a[j] = tmp;
			adjustHeapRec(a, 0, j);
			j --;
		}
	}
	
	public static void main(String[] args) {
		int[] a = {3,4,1,5,2};
		HeapSort t = new HeapSort();
		int n = a.length;
		t.buildHeap(a, 0, n-1, n);
		t.deleteHeap(a, n);
		//输出排序后的数组
		boolean flag = true;
		for(int i = n-1; i >= 0; i --) {
			if(flag) flag = false;
			else
				System.out.print(" ");
			System.out.print(a[i]);
		}
		System.out.println();
	}

}

还有就是向堆中插入一个元素，只需要判断该元素与其父结点的关系，向上调整。

	/*
	 * 插入元素：插入结点i，其父节点的坐标为(i-1)/2
	 */
	private void insertElem(int[] a, int i) {
		int min = i;
		while(i > 0) {
			int father = (i-1)/2;
			if(father >= 0 && a[father] < a[i])
				min = father;
			if(min == i) {
				int tmp = a[i];
				a[father] = a[i];
				a[i] = tmp;
				i = father;
			}
		}
	}