堆排序是利用“堆”这种数据结构性质的一种选择排序算法。堆是完全二叉树并且具有以下的性质:
大顶堆:它的左右子结点都比自己结点的值小。数学公式表达:A[k] >= A[2k+1] && A[k] >= A[2k+2]
小顶堆:它的左右子结点都比自己结点的值大。数学公式表达:A[k] <= A[2k+1] && A[k] <= A[2k+2]
一般大顶堆用于升序排序,小顶堆用于降序排序
堆排序是不稳定的排序算法
时间复杂度:O(n*logN)
空间复杂度:O(1)
public class HeapSort {
public static void main(String[] args) {
int[] sort = new int[] { 1, 0, 10, 20, 3, 5, 6, 4, 9, 8, 12,17, 34, 11 };
buildMaxHeapify(sort);
heapSort(sort);
}
/**
* 没有子节点的才需要创建最大堆,从最后一个的父节点开始
* 从尾端开始创建最大堆,每次都是正确的堆
* @param data
*/
private static void buildMaxHeapify(int[] data) {
int startIndex = getParentIndex(data.length - 1);
for (int i = startIndex; i >= 0; i--) {
maxHeapify(data, data.length, i);
}
}
/**
* 创建最大堆
*
* @paramdata
* @paramheapSize需要创建最大堆的大小,一般在sort的时候用到,因为最多值放在末尾,末尾就不再归入最大堆了
* @paramindex当前需要创建最大堆的位置
* 比较左右子节点与父节点的大小,选出最大值,然后交换,最后重新调整堆
*
*/
private static void maxHeapify(int[] data, int heapSize, int index) {
print(data);
System.out.println("heapSize:"+heapSize+" ;index: "+index);
// 当前点与左右子节点比较
int left = getChildLeftIndex(index);
int right = getChildRightIndex(index);
int largest = index;
if (left < heapSize && data[index] < data[left]) {
largest = left;
}
if (right < heapSize && data[largest] < data[right]) {
largest = right;
}
// 得到最大值后可能需要交换,如果交换了,其子节点可能就不是最大堆了,需要重新调整
if (largest != index) {
int temp = data[index];
data[index] = data[largest];
data[largest] = temp;
maxHeapify(data, heapSize, largest);
}
}
/**
* 排序,最大值放在末尾,data虽然是最大堆,在排序后就成了递增的
*
*/
private static void heapSort(int[] data) {
// 末尾与头交换,交换后调整最大堆
for (int i = data.length - 1; i > 0; i--) {
int temp = data[0];
data[0] = data[i];
data[i] = temp;
maxHeapify(data, i, 0);
}
}
/**
* 父节点位置
* @return ParentIndex
*/
private static int getParentIndex(int current) {
return (current - 1) >> 1;
/**
* 左子节点position注意括号,加法优先级更高
* @return
*/
private static int getChildLeftIndex(int current) {
return (current << 1) + 1;
}
/**
* 右子节点position
* @return ChildRightIndex
*/
private static int getChildRightIndex(int current) {
return (current << 1) + 2;
}
}