一、思想

对数组中[0,n-1]范围内的数从小到大排序。

1. 将[0,n-1]范围内的数调整为最大堆，将第0个元素和第n-1个元素交换位置；
2. 将[0,n-2]范围内的数调整为最大堆，将第0个元素和第n-2个元素交换位置；
   ……
3. 将[0,1]范围内的数调整为最大堆，将第0个元素和第1个元素交换位置

上述过程是一个循环过程

for(int i=n-1;i>=1;i--){
  // 将[0,i]范围内的数调整为最大堆
  buildMaxHeap(nums,0,i);
  // 将第0个元素和第i个元素交换位置
  swap(nums,0,i);
}

核心操作过程就是buildMaxHeap(nums,0,i)：从最后一个父节点（parent(i)）开始调整，一直调整到根节点0。针对每一个节点x：若该节点有左子节点，则从该节点、其左子节点、右子节点（如果有的话）中找出最大的值的坐标largest。若largest和x的坐标不同：则交换largest和x的位置，同时调整节点largest；若largest和x的坐标相同：调整下一个节点。

buildMaxHeap(nums,0,i){
  int begin=parent(i);
  for(int i=begin;i>=0;i--){
    // 当前正在操作的节点cur
    while(cur有左子节点){
      largest=找出节点cur、其左子节点、右子节点（如果有的话）中最大值下标
      if(largest!=cur){
          swap(nums,largest,cur);
          cur=largest;
      }else{
          break;
      }
    }
  }
}

二、实现

import java.util.Arrays;
import java.util.Random;

public class 堆排序 {
    public static void main(String[] args) {
        new 堆排序().exe();
    }

    private final int N = 10;// 数组的大小
    Random rand = new Random();
    private void exe() {
        int[] A = new int[N];
        for (int i = 0; i < N; i++) {
            A[i] = rand.nextInt(1000);
        }
//      int[] A={7,6,5,8,10};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(A));

        heapSort(A);

        System.out.println("排序后（升序）：");
        System.out.println(Arrays.toString(A));     
    }

    /**
     * 利用最大堆将数组按从小到大的顺序排列
     * 
     * @param nums
     *            ：数组从下标0开始存储
     */
    public void heapSort(int[] nums) {
        int length = nums.length;
        if (length <= 1) {
            return;
        }
        int count=1;
        for (int i = length - 1; i >= 1; i--) {
            // 将[0,i]范围内的数调整为大顶堆
            buildMaxHeap(nums, 0, i);
            // 交换第0处节点和第i处节点
            swap(nums, 0, i);
            System.out.println("第"+count+++"次交换");
            System.out.println(Arrays.toString(nums));
        }

    }

    private void swap(int[] nums, int a, int b) {
        int temp=nums[a];
        nums[a]=nums[b];
        nums[b]=temp;
    }

    /**
     * 将[l,h]范围内的数调整为大顶堆
     * 
     * @param nums
     * @param l
     * @param h
     */
    private void buildMaxHeap(int[] nums, int l, int h) {
        if (l >= h) {
            return;
        }
        // 从最后一个节点的父节点开始调整，依次向上调整到根节点
        int begin = parent(h);
        for (int i = begin; i >= l; i--) {
            // 针对每一个节点，从该节点开始依次向下调整（因为如果发生节点交换，影响了下面的节点）
            // 当节点的左节点或右节点存在时调整，否则无需调整
            int cur=i;// 循环变量
            while(isExists(left(cur),h)){
                int left=left(cur);
                int right=right(cur);
                // 找出三个中最大的
                int largest=cur;
                // 和左节点比较
                largest=nums[left]>nums[largest]?left:largest;
                // 如果右节点存在：和右节点比较
                if(isExists(right,h)){
                    largest=nums[right]>nums[largest]?right:largest;
                }
                if(largest!=cur){
                    swap(nums,largest,cur);
                    cur=largest;
                }else{
                    break;
                }
            }
        }
    }
    
    /**
     * 判断节点是否存在
     * @param i
     * @param high
     * @return
     */
    public boolean isExists(int i,int high){
        if(i<=high){
            return true;
        }
        return false;
    }

    public int parent(int i) {
        return (i - 1) / 2;
    }

    public int left(int i) {
        return 2 * i + 1;
    }

    public int right(int i) {
        return 2 * i + 2;
    }
}

三、注意事项

三、参考文献