Java与数据结构——树的应用（堆排序）

堆排序

基本介绍：（1）堆排序是利用 堆 这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最好、最坏、平均时间复杂度均为 O（nlogn），它是不稳定排序；（2）堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆。注意：没有要求节点的左孩子的值和右孩子的值的关系；（3）每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆。

大顶堆特点： arr[i] >= arr[2*i+1] && arr[i] >= arr[2*i+2]；

小顶堆特点： arr[i] <= arr[2*i+1] && arr[i] <= arr[2*i+2]；

 （4）一般升序采用大顶堆，降序采用小顶堆。

堆排序的基本思想：

（1）将待排序的序列构造成一个大顶堆；

（2）此时，整个序列最大的值就是堆顶的根节点；

（3）将其与末尾元素进行交换，此时末尾就成了最大值；

（4）然后将剩余的 n-1 个元素重新构造称为一个堆，这样会得到 n 个元素的次大（小）值；

（5）如此反复执行就能得到一个有序序列。

应用实例：给你一个数组{4， 6， 8， 5， 9}，要求使用堆排序，将数组升序排列。

步骤一：构造初始堆，将给定的无序序列构造成一个大顶堆（升序大顶堆，降序小顶堆）

1）假定给定的无序序列结构如下

 2）此时，从最后一个非叶子节点开始（叶子节点自然不用调整，第一个非叶子节点  arr.length/2 - 1 = 5/2 - 1 = 1，也就是下面的 6 节点），从左至右，从下至上进行调整，

3）找到第二个非叶子子节点 ，由于【4， 9， 8】中 9 最大，将 4 和 9 进行交换 

4）这时，由于交换导致子树【4， 5， 6】结构混乱，继续调整，【4， 5， 6】中 6 最大，将 4 和 6 进行交换

 

 此时，终于构成一个大顶堆。

步骤二：将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大的元素。如此反复进行交换、重建堆、再交换。

1）将堆顶元素 9 与末尾元素 4 进行交换

2）重新调整结构，使其继续满足大顶堆定义

3）再将堆顶元素 8 与末尾元素 5 进行交换，得到第二大元素 8

4）后序过程，继续进行调整、交换，如此反复进行，最终使得整个序列有序

代码实现：

package tree;
import java.util.Arrays;
public class HeapSort {
    public static void main(String[] args) {
        //将数组进行升序排列
        int[] arr = {4, 6, 8, 5, 9, 2};
        heapSort(arr);
    }
    //编写一个堆排序的方法
    public static  void heapSort(int[] arr){
        System.out.println("堆排序！！");
        int temp = 0;//临时变量
        /*分步完成
        adjustHead(arr,1, arr.length);
        System.out.println("第一次：" + Arrays.toString(arr));
        adjustHead(arr,0, arr.length);
        System.out.println("第二次：" + Arrays.toString(arr));
         */
        //将给定的无序序列构造成一个大顶堆（升序大顶堆，降序小顶堆）
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHead(arr,i, arr.length);
        }
        //将堆顶元素与末尾元素进行交换，使末尾元素最大。
        // 然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大的元素。
        // 如此反复进行交换、重建堆、再交换。
        for (int i = arr.length - 1; i >0; i--) {
            //交换
            temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjustHead(arr,0,i);
        }
        System.out.println("堆排序后的数组：" + Arrays.toString(arr));
    }
    //将一个数组（二叉树），调整成一个大顶堆
    /*
    功能：完成将以 i 对应的非叶子节点的树调整为大顶堆
    举例：int[] arr = {4, 6, 8, 5, 9}; =====> i=1 =====> 得到 arr = {4, 9, 8, 5, 6}
    再次调用adjustHeap 传入 i=0 =====> 得到 arr = {9, 4, 8, 5, 6}
    与大顶堆定义不符  再次调整 传入 i=1 =====> 得到 arr= {9, 6, 8, 5, 4}
    arr        待调整的数组
    i         表示非叶子节点在数组中的索引
    length    表示对多少个元素进行继续调整，length是在逐渐减少
     */
    public static void adjustHead(int[] arr, int i, int length){
        int temp = arr[i];//先取出当前元素的值，保存在临时变量
        //开始调整
        //说明
        //1. k = i*2+1 k是第 i 个节点的左子节点
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1){
            if (k+1 < length && arr[k] < arr[k+1]){
                //说明左子节点的值小于右子节点的值
                k++;// k 指向右子节点
            }
            if (arr[k] > temp){//如果子节点大于父节点
                arr[i] = arr[k];//把较大的值赋给当前节点
                i = k;//！！！ i 指向 k ，继续循环比较
            }else {
                break;//
            }
        }
        //当 for 循环结束后，我们已经将 以 i 为父节点的树的最大值，放在了局部最顶
        arr[i] = temp;//将temp放到调整后的位置
    }
}