堆排序 java

堆排序是使用二叉树模型，建立最大堆或最小堆，将最大值或最小值上浮，降低遍历次数，增加排序效率的一种解决方法。

由于堆排序时使用的是完全二叉模型，所以可以使用数组进行表示。

在使用堆排序时，需要使用到完全二叉树的一些公式，如父节点n/2-1，左子节点2i+1，右子节点2i+2，叶子节点(>size/2)等。具体见代码。

1、首先定义堆模型的一些常用操作接口。

package cn.dream.sort;

public interface IHeapSort {

/**
* 获取父节点的位置
* 完全二叉树父节点位置在（n-1）/2处
* @param i
* @return
*/
int getParent(int i);

/**
* 获取左子位置
* 完全二叉树左子节点在2*i+1处
* @param i
* @return
*/
int getLeftChild(int i);

/**
* 获取右子位置
* 完全二叉树右子节点在左子节点的后面（2*i+1）+1
* @param i
* @return
*/
int getRightChild(int i);

/**
* 建堆
* 从n/2-1处开始调整树结构，因为从n/2处都是叶子节点，不需要调整
* @param a
* @param size
*/
int[] buildHeap(int[] a, int size);

/**
* 调整堆
* 通过对堆的调整，使其满足堆结构的要求，最大值上浮或最小值上浮。
* 对于任一节点进行调整时：
* 1、最大堆：如果该节点比（左右子节点最大值）小，交换该节点和最大值位置，然后调整树
* 2、最小堆：如果该节点比（左右子节点最小值）大，交换该节点和最小值位置，然后调整树
* @param a
* @param i
* @param size
*/
int[] adjustHeap(int[] a, int i, int size);

/**
* 堆排序
* 1、最小堆：
* 方法一：执行遍历{将根节点（min）取出，构建树}
* 方法二：执行遍历{将根节点（min）和最后一个节点（数组最后一位）交换，将参与构建的数组长度-1（移动size的index），重新构建树结构}，最后倒序输出
* 2、最大堆：执行遍历{将根节点（max）和最后一个节点（数组最后一位）交换，将参与构建的数组长度-1（移动size的index），重新构建树结构}
* @param a
* @param size
*/
int[] sortHeap(int[] a, int size);

}


然后分别建立最大堆和最小堆，进行编码测试
最小堆

package cn.dream.sort;

import java.util.Arrays;

public class MinHeapSortImpl implements IHeapSort {

@Override
public int getParent(int i) {
return (int) (i - 1) / 2;
}

@Override
public int getLeftChild(int i) {
return 2 * i + 1;
}

@Override
public int getRightChild(int i) {
return 2 * i + 2;
}

@Override
public int[] buildHeap(int[] a, int size) {
for (int i = (size - 2) / 2; i >= 0; i--) {
adjustHeap(a, i, size);
}
return a;
}

@Override
public int[] adjustHeap(int[] a, int i, int size) {
int min = i;
int temp = a[i];
int left = getLeftChild(i);
int right = getRightChild(i);

if (left < size && a[left] < temp) {
min = left;
}

if (right < size && a[right] < a[min]) {
min = right;
}

if (min != i) {
a[i] = a[min];
a[min] = temp;
adjustHeap(a, min, size);
}
return a;
}

@Override
public int[] sortHeap(int[] a, int size) {
int[] b = new int[a.length];
int i = 0;
while(size>0) {
b[i] = a[0];
a[0] = a[size - 1];
--size;
adjustHeap(a, 0, size);

i++;
}
return b;
}

public static void main(String[] args) {
int[] arr = { 53, 4, 24, 47, 41, 97, 13, 83, 12, 35, 11, 15, 41, 18,
68, 49, 36, 52, 9, 45, 0, 38, 36, 82, 76, 22, 44, 35, 34, 81,
94, 70, 88, 30, 42, 45, 55, 75, 93, 57, 74, 0, 77, 64, 93, 58,
15, 62, 13, 49, 60, 21, 3, 66, 15, 74, 48, 96, 52, 56, 63, 73,
85, 44, 39, 42, 98, 38, 17, 81, 7, 60, 86, 79, 63, 66, 17, 78,
78, 90, 23, 92, 79, 21, 80, 71, 6, 70, 59, 25, 41, 11, 64, 60,
62, 51, 93, 46, 18, 31 };

long startTime = System.currentTimeMillis();

IHeapSort heapSort = new MinHeapSortImpl();

System.out.println("测试最小堆的根节点是否最小值：");
heapSort.buildHeap(arr, arr.length);
System.out.println("root is:" + arr[0]);

System.out.println("测试最小堆是否已经排序：");
System.out.println(Arrays.toString(arr));

System.out.println("排序：");
int[] heap = heapSort.sortHeap(arr, arr.length);
System.out.println(Arrays.toString(heap));

System.out.println((System.currentTimeMillis() - startTime) + "ms");

}
}


最大堆
package cn.dream.sort;

import java.util.Arrays;

public class MaxHeapSortImpl implements IHeapSort {

@Override
public int getParent(int i) {
return (int) (i - 1) / 2;
}

@Override
public int getLeftChild(int i) {
return 2 * i + 1;
}

@Override
public int getRightChild(int i) {
return 2 * i + 2;
}

@Override
public int[] buildHeap(int[] a, int size) {
for (int i = (size - 2) / 2; i >= 0; i--) {
adjustHeap(a, i, size);
}
return a;
}

@Override
public int[] adjustHeap(int[] a, int i, int size) {
int largest = i;
int temp = a[i];
int left = getLeftChild(i);
int right = getRightChild(i);

if (left < size && a[left] > temp) {
largest = left;
}

if (right < size && a[right] > a[largest]) {
largest = right;
}

if (largest != i) {
a[i] = a[largest];
a[largest] = temp;
adjustHeap(a, largest, size);
}
return a;
}

@Override
public int[] sortHeap(int[] a, int size) {
// buildHeap(a, size);
int temp;
for (int i = size - 1; i >= 0; i--) {
temp = a[0];
a[0] = a[i];
a[i] = temp;
adjustHeap(a, 0, i);
}
return a;
}

public static void main(String[] args) {
int[] arr = { 53, 4, 24, 47, 41, 97, 13, 83, 12, 35, 11, 15, 41, 18,
68, 49, 36, 52, 9, 45, 0, 38, 36, 82, 76, 22, 44, 35, 34, 81,
94, 70, 88, 30, 42, 45, 55, 75, 93, 57, 74, 0, 77, 64, 93, 58,
15, 62, 13, 49, 60, 21, 3, 66, 15, 74, 48, 96, 52, 56, 63, 73,
85, 44, 39, 42, 98, 38, 17, 81, 7, 60, 86, 79, 63, 66, 17, 78,
78, 90, 23, 92, 79, 21, 80, 71, 6, 70, 59, 25, 41, 11, 64, 60,
62, 51, 93, 46, 18, 31 };

long startTime = System.currentTimeMillis();

IHeapSort heapSort = new MaxHeapSortImpl();

System.out.println("测试最大堆的根节点是否最大值：");
heapSort.buildHeap(arr, arr.length);
System.out.println("root is:" + arr[0]);

System.out.println("测试最大堆的顺序是否为倒序：");
System.out.println(Arrays.toString(arr));

System.out.println("排序：");
heapSort.sortHeap(arr, arr.length);
System.out.println(Arrays.toString(arr));

System.out.println((System.currentTimeMillis() - startTime) + "ms");

}

}


更多排序，，参考这位的http://blog.csdn.net/han_xiaoyang/article/details/12163251