数据结构与算法(22):堆排序(二叉树)及其相关案例

1.堆排序基本介绍

1. 堆排序是利用堆这种数据结构而设计的一种排序算法,堆排序是一种选择排序,它的最坏,最好,平均时间复杂度均为O(nlogN),它是一种不稳定的排序
2. 堆是具有以下性质的完全二叉树,每个节点的值都大于或者等于其左右孩子节点的值
   称为大顶堆.**注意:**没有要求节点的左孩子和右孩子的大小关系
3. 每个结点的值都小于或等于其左右孩子节点的值,称为小顶堆
4. 大顶堆举例说明
   
   我们对堆中的结点按层进行编号，映射到数组中就是下面这个样子:
   

大顶堆特点：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] // i 对应第几个节点，i从0开始编号

小顶堆的举例说明

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] // i 对应第几个节点，i从0开始编号
一般升序采用大顶堆，降序采用小顶堆

二. 堆排序的基本思想

1. 将待排序序列构造成一个大顶堆
2. 此时,整个序列的最大值就是对顶的根节点
3. 将其与末尾元素进行交换,此时的末尾就为最大值
4. 然后将剩余n-1个元素重新构造成一个堆,这样就会得到n个元素的次小值,如此反复执行,便能的到一个有序序列了

可以看到在构建一个大顶堆的过程中,元素的个数逐渐减少,最后得到一个有序序列了

图解如下:

代码实现:

package com.qiu.tree;

import java.util.Arrays;

/**
 * @author qiuzhikang
 */
public class HeapSort {
    public static void main(String[] args) {
        //要求将数组进行一个升序排列
        int[] arr = {4,6,8,5,9};
        heapSort(arr);
    }
    //编写一个堆排序的方法
    public static void heapSort(int arr[]){
        System.out.println("堆排序");
        int temp = 0;
        //分布完成
//        adjustHeap(arr,1,arr.length);
//        System.out.println("第一次调整之后:"+ Arrays.toString(arr));
//        adjustHeap(arr,0,arr.length);
//        System.out.println("第二次调整之后:"+ Arrays.toString(arr));
        //将无序序列构建成一个堆
        for (int i = arr.length / 2 - 1; i >=0; i--) {
            adjustHeap(arr,i,arr.length);
        }

        //调整结构满足堆定义
        for (int j = arr.length - 1; j>0; j--) {
            //交换
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr,0,j);
        }
        System.out.println("数组:"+Arrays.toString(arr));
    }


    /**
     * 将一个数组(二叉树),调整成一个大顶堆
     * 完成将以i 对应的非叶子节点的树调整成大顶堆
     * 举例 int arr[]  = {4,6,8,5,9}; i = 1 =>adjustHeap => 得到{4,9,8,5,6}
     * 如果我们再调用adjustHeap,传入的是i = 0得到{9,6,8,5,4}
     * @param arr 待调整的数组
     * @param i 表示非叶子节点的在数组中的索引
     * @param length 表示对多少个元素进行调整(调整中不断地减少的
     */
    public static void adjustHeap(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为父节点的这颗树的最大值,放在了最顶上(局部)
        //将temp值放到调整后的位置
        arr[i] = temp;
    }

}

堆排序速度速度测试:

 //要求将数组进行一个升序排列
        int[] arr1 = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            arr1[i] =(int)(Math.random()*80000000);

        }
        //测试排序时间
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = format.format(date);
        System.out.println("排序前的时间:"+dateStr);
        heapSort(arr1);

        Date date1 = new Date();
        SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr1 = format1.format(date1);
        System.out.println("排序后的时间:"+dateStr1);
    }

结果:

结果说明堆排序的速度还是很快的