本文我准备用Java实现堆排序。其实我以前在用二叉大顶堆实现优先队列的时候，就已经顺便实现了堆排序，今天把其中堆排序的代码提取出来，专门作为排序的一篇博文，并附上以前用二叉大顶堆实现的优先队列，以及顺便实现堆排序的博文地址：点我查看。具体的排序算法过程已经在注释里面了，大家可以复制代码到IDE里面，用DEBUG模式研究算法的过程：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
/**
* @author LiYang
* @ClassName HeapSort
* @Description 堆排序算法
* @date 2019/11/5 16:04
*/
public class HeapSort {
//本例的堆排序，用优先队列来实现
//下面是二叉大顶堆的底层数据存储
private List<Integer> elementData;
/**
* 堆排序的带初始值的构造方法
* 也就是先拿待排序的数组的所有数据先初始化一个二叉大顶堆，
* 然后在这个大顶堆的基础上再进行一系列poll操作，创建有序序列
* @param initialArray 初始数据
*/
public HeapSort(int[] initialArray){
//调用初始化大顶堆的方法
elementData = initialPriorityHeap(initialArray);
}
/**
* 将已经存在的乱序数组，初始化为大顶堆elementData，用作构造方法
* 也就是说，效果就像乱序数组都add到了优先队列那样
* 如果是泛型，则接受ArrayList<T>，然后用compare方法实现
* @param arr 刚开始存在的数据，乱序的
* @return 已经放入arr数组的数字的优先队列
*/
private List<Integer> initialPriorityHeap(int[] arr){
//先将数组转化为ArrayList，方便后续操作
List<Integer> elementData = new ArrayList(arr.length);
//遍历加入
for (int i = 0; i < arr.length; i++) {
elementData.add(arr[i]);
}
//如果只有一个元素，甚至没有元素，就直接返回
if (elementData.size() <= 1){
return elementData;
}
//我们从最后一个元素的父元素开始，一个个尝试往下渗透
int maxParentIndex = elementData.size() / 2;
//从最后一个元素的父元素开始，开始逐一往下渗透
for (int index = maxParentIndex; index > 0; index--){
//取到父元素的值
int parentValue = elementData.get(index - 1);
//取到父元素的下标
int parentIndex = index;
//逐渐往下渗透，直到不能再下去了为止
while (parentIndex <= elementData.size() / 2){
//找到下标较小的子元素的下标
int smallerIndexSon = parentIndex * 2;
//找到下标较大的子元素的下标
int biggerIndexSon = smallerIndexSon + 1;
//如果下标较大的子元素不存在
if (biggerIndexSon > elementData.size()){
//就只跟下标较小的子元素相比
//如果移动上去的末尾元素比子元素小，就交换
if (parentValue < elementData.get(smallerIndexSon - 1)){
//二者交换
int temp = elementData.get(smallerIndexSon - 1);
elementData.set(smallerIndexSon - 1, elementData.get(parentIndex - 1));
elementData.set(parentIndex - 1, temp);
//更新下标为下标较小的子元素的下标
index = smallerIndexSon;
//否则，结束往下渗透
} else {
break;
}
//如果下标较大的子元素存在
} else {
//如果较大下标子元素比较小下标子元素大
if (elementData.get(biggerIndexSon - 1) > elementData.get(smallerIndexSon - 1)){
//尝试与较大下标子元素交换
if (elementData.get(biggerIndexSon - 1) > parentValue){
int temp = elementData.get(biggerIndexSon - 1);
elementData.set(biggerIndexSon - 1, elementData.get(parentIndex - 1));
elementData.set(parentIndex - 1, temp);
//更新下标为下标较大的子元素的下标
parentIndex = biggerIndexSon;
//如果子元素不小于较大下标元素，则停止向下渗透
} else {
break;
}
//如果较大下标元素不比较小下表元素大
} else {
//尝试与较小下标子元素交换
if (elementData.get(smallerIndexSon - 1) > parentValue){
int temp = elementData.get(smallerIndexSon - 1);
elementData.set(smallerIndexSon - 1, elementData.get(parentIndex - 1));
elementData.set(parentIndex - 1, temp);
//更新下标为下标较小的子元素的下标
parentIndex = smallerIndexSon;
//如果子元素不小于较大下标元素，则停止向下渗透
} else {
break;
}
}
}
}
}
//最后返回建好的大顶堆elementData
return elementData;
}
/**
* 从优先队列里面弹出优先级最高的元素，用作排序
* 注意，每次poll了之后，剩下的elementData的第一个是之前第二大的
* @return 返回优先级最高的元素，或者null
*/
public Integer poll(){
//如果没有元素了，返回空
if (elementData.size() == 0){
return null;
}
//如果只有一个元素，直接返回该元素
if (elementData.size() == 1){
return elementData.remove(0);
}
//先将第一个，也就是优先级最高的元素取出
int maxPriority = elementData.get(0);
//将最后一个元素取出来，并移除
int lastElement = elementData.remove(elementData.size() - 1);
//最后一个元素，加在队首，也就是第一个，其他的往后移
elementData.set(0, lastElement);
//如果最后一个元素不是最大的，得往下渗透
int index = 1;
//如果该元素还有子元素
while (index <= elementData.size() / 2){
//找到下标较小的子元素的下标
int smallerIndexSon = index * 2;
//找到下标较大的子元素的下标
int biggerIndexSon = smallerIndexSon + 1;
//如果下标较大的子元素不存在
if (biggerIndexSon > elementData.size()){
//就只跟下标较小的子元素相比
//如果移动上去的末尾元素比子元素小，就交换
if (lastElement < elementData.get(smallerIndexSon - 1)){
//二者交换
int temp = elementData.get(smallerIndexSon - 1);
elementData.set(smallerIndexSon - 1, elementData.get(index - 1));
elementData.set(index - 1, temp);
//更新下标为下标较小的子元素的下标
index = smallerIndexSon;
//否则，结束往下渗透
} else {
break;
}
//如果下标较大的子元素存在
} else {
//如果较大下标子元素比较小下标子元素大
if (elementData.get(biggerIndexSon - 1) > elementData.get(smallerIndexSon - 1)){
//尝试与较大下标子元素交换
if (elementData.get(biggerIndexSon - 1) > lastElement){
int temp = elementData.get(biggerIndexSon - 1);
elementData.set(biggerIndexSon - 1, elementData.get(index - 1));
elementData.set(index - 1, temp);
//更新下标为下标较大的子元素的下标
index = biggerIndexSon;
//如果子元素不小于较大下标元素，则停止向下渗透
} else {
break;
}
//如果较大下标元素不比较小下表元素大
} else {
//尝试与较小下标子元素交换
if (elementData.get(smallerIndexSon - 1) > lastElement){
int temp = elementData.get(smallerIndexSon - 1);
elementData.set(smallerIndexSon - 1, elementData.get(index - 1));
elementData.set(index - 1, temp);
//更新下标为下标较小的子元素的下标
index = smallerIndexSon;
//如果子元素不小于较大下标元素，则停止向下渗透
} else {
break;
}
}
}
}
//最后返回优先级最大的元素
return maxPriority;
}
/**
* 堆排序（通过二叉大顶堆的优先队列，实现堆排序）
* @param arr 排序前的数组
* @param increase 是否升序排序
* @return 返回排序后的数组
*/
public static int[] heapSort(int[] arr, boolean increase){
//先用排序前的数组，构建一个最大堆
HeapSort heapSort = new HeapSort(arr);
//声明一个空数组，用于装排好序的数组
int[] sortedArray = new int[arr.length];
/*
* 通过不断地poll，生成从大到小有序的序列，并放到上面的数组中
*/
//如果是升序排序
if (increase){
for (int i = sortedArray.length-1; i >= 0; i--) {
sortedArray[i] = heapSort.poll();
}
//如果是降序排序
} else {
for (int i = 0; i < sortedArray.length; i++) {
sortedArray[i] = heapSort.poll();
}
}
//返回排好序的数组
//如果是小顶堆实现，则poll出来的就是从小到大
return sortedArray;
}
/**
* 堆排序(HeapSort)的驱动程序
* @param arr 待排序数组
* @return 堆排序完成后的有序数组
*/
public static int[] heapSort(int[] arr) {
//调用升序的堆排序，并将排好序的数组返回
return heapSort(arr, true);
}
/**
* 验证堆排序算法
* @param args
*/
public static void main(String[] args) {
//待排序数组
int[] arr = new int[30];
//随机数类
Random random = new Random();
//随机生成排序数组（100以内的整数）
for (int i = 0; i < arr.length; i++) {
arr[i] = random.nextInt(100);
}
//打印待排序数组
System.out.println("堆排序前：" + Arrays.toString(arr));
//进行堆排序（调用驱动程序，就是只有一个参数的heapSort()方法）
//注意，堆排序跟之前的排序不太一样，要返回排好序的数组
//而不是最后有序的数组就是原来的数组
int[] heapSortedArr = heapSort(arr);
//这里可以将排好序的数组，重新赋给原来的数组，保持之前的操作
arr = heapSortedArr;
//打印堆排序后的数组
System.out.println("堆排序后：" + Arrays.toString(arr));
}
}运行 HeapSort 类的main方法，堆排序算法测试通过：
堆排序前：[49, 59, 18, 34, 7, 23, 98, 33, 37, 36, 78, 54, 12, 78, 14, 83, 57, 90, 96, 76, 1, 39, 32, 97, 11, 35, 28, 35, 54, 99]
堆排序后：[1, 7, 11, 12, 14, 18, 23, 28, 32, 33, 34, 35, 35, 36, 37, 39, 49, 54, 54, 57, 59, 76, 78, 78, 83, 90, 96, 97, 98, 99]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
