堆排序

最大堆：堆顶为整个堆中最大元素的堆称为最大堆。

最小堆：堆顶为整个堆中最小元素的堆称为最小堆。

堆排序步骤：

1.把无序数组构建成二叉堆。需要从小到大排序，则构建成最大堆；需要从大到小排序，则构建成最小堆。

2.循环删除堆顶元素，替换到二叉堆的末尾，调整堆顶产生新的堆顶。

下边为具体的代码

package com.company;

import java.lang.reflect.Array;
import java.util.Arrays;

public class qt {
    /**
     * “下沉”调整
     * @para array  待调整的堆
     * @para parentIndex  要下沉的父节点
     * @para length  堆的有效大小
     */
    public static void downAdjust(int[] array,int parentIndex,int length) {
        //temp保存父节点的值，用于最后的赋值
        int temp = array[parentIndex];
        int childIndex = 2 * parentIndex + 1;
        while (childIndex < length) {
            //如果有右孩子，且右孩子的值大于左孩子，则定位到右孩子
            if (childIndex + 1 < length && array[childIndex + 1] > array[childIndex]) {
                childIndex++;
            }
//如果父节点大于任何一个孩子的值，则直接跳出
            if (temp >= array[childIndex])
                break;
                //无需真正交换，单向赋值即可
                array[parentIndex]=array[childIndex];
                parentIndex = childIndex;
                childIndex = 2 * childIndex + 1;
            }
            array[parentIndex] = temp;
        }
/**
 * 堆排序（升序）
 * @param array 待调整的堆
 */
public static void heapSort(int []array){
    //1.把无序数组构建成最大堆
            for(int i=(array.length-2)/2;i>=0;i--){
                downAdjust(array, i, array.length);
            }
            System.out.println(Arrays.toString(array));
            //2.循环删除堆顶元素，移到集合尾部，调整堆产生新的堆顶
            for(int i=array.length-1;i>0;i--){
                //最后一个元素和第一个元素进行交换
                int temp=array[i];
                array[i]=array[0];
                array[0]=temp;
                //“下沉”调整最大堆
                downAdjust(array, 0, i);
            }
        }
        public static void main(String[]args){
    int []arr=new int[]{1,3,2,6,5,7,8,9,10};
    heapSort(arr);
    System.out.println(Arrays.toString(arr));
        }
    }

程序运行结果如下：

 

[10, 9, 8, 6, 5, 7, 2, 3, 1]
[1, 2, 3, 5, 6, 7, 8, 9, 10]

Process finished with exit code 0