堆排序(详情讲解)

1.概述

     

  小顶堆:每个节点的值都小于或者等于它的左右子节点的值

 

2.0示意图

 大堆顶:

  • 堆排序是一种重要的选择排序方法,它只需要一个记录大小的辅助存储空间,每个待排序的记录仅占用一个记录大小的存储空间,因此弥补了树形选择排序的弱点。

  • 大顶堆:每个节点的值都大于或者等于它的左右子节点的值。

  • 一般升序采用大顶堆,降序采用小顶堆

堆排序(详情讲解)_第1张图片

  • 基本思想:

    • 首先将这n条记录按关键字值的大小建立堆(称为初始堆),将堆顶元素r[0]与r[n-1]交换

    • 然后,将剩下的{r[0]..r[n-2]}序列调整成堆

    • 再将 r[0]与r[n-2]交换,再将剩下的{r[0]..r[n-3]}序列调整成堆

    • 如此反复,直到整个序列有序。

    • 这个过程称为堆排序

  • 要实现堆排序需解决以下两个主要问题:

    1. 将n条记录的序列按关键字值的大小建成初始堆。

    2. 将堆顶记录r[0]与r[i]交换后,如何将序列{r[0]..r[i-1]}按其关键字值的大小调整成一个新堆

3.0筛选法调整堆:算法

  • 代码
//将以low为根的子树调整成小顶堆,low、high是序列下界和上界
public void sift(int low, int high) {
    int i = low;                                //子树的根
    int j = 2 * i + 1;                         //j为i结点的左孩子
    RecordNode temp = r[i];
    while (j < high) {  //沿较小值孩子结点向下筛选
        if (j < high - 1 && r[j].key.compareTo(r[j + 1].key) > 0) {
            j++; //数组元素比较,j为左右孩子的较小者
        }
        if (temp.key.compareTo(r[j].key) > 0) { //若父母结点值较大
            r[i] = r[j];           //孩子结点中的较小值上移
            i = j;
            j = 2 * i + 1;
        } else {
            j = high + 1;          //退出循环
        }
    }
    r[i] = temp;                   //当前子树的原根值调整后的位置
//  System.out.print("sift  " + low + ".." + high + "  ");
//  display();
  • 测试
public class TestSeqList11_sift {
    public static void main(String[] args) throws Exception {
        int[] arr = {13,25,18,33,58,95,46,63};
        SeqList seqList = new SeqList(arr.length);
        System.out.print("序列号:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + i);
            seqList.insert(i, new RecordNode(arr[i]));
        }
        System.out.println();
        System.out.print("原数据:");
        seqList.display();
        // 树形选择排序(锦标赛排序)
        RecordNode temp = seqList.r[0];
        seqList.r[0] = seqList.r[arr.length - 1];
        seqList.r[arr.length-1] = temp;
        System.out.print("交换值:");
        seqList.display();
        seqList.sift(0, arr.length-1);
        System.out.print("调整后:");
        seqList.display();
    }
}
//树形选择排序(锦标赛排序)
//序列号:  0  1  2  3  4  5  6  7
//原数据: 13 25 18 33 58 95 46 63
//交换值: 63 25 18 33 58 95 46 13
//调整后: 18 25 46 33 58 95 63 13

4.0建初始堆

  • 为一个无序序列构建堆的过程,就是对完全二叉树从下往上反复筛选的过程。也就是说每一个结点与自己的孩子结点进行比较,从而选择出最小元素。

  • 有孩子的结点,称为非叶子结点,在完全二叉树中,最后一个非叶子结点的编号为 ⌊n/2⌋ -1

  • 因此我们从最后一个非叶子结点开始调整,最后调整到根节点堆排序(详情讲解)_第2张图片

       //序列号:          0  1  2  3  4  5  6  7
       //sift  3..8   33 25 46 13 58 95 18 63
       //sift  2..8   33 25 18 13 58 95 46 63
       //sift  1..8   33 13 18 25 58 95 46 63
       //sift  0..8   13 25 18 33 58 95 46 63

 

5.0堆排序:分析

  • 步骤:

  1. 首先通过对 ⌊n/2⌋ -1记录进行调整,构建堆。

  2. 然后将堆顶的元素,与最后一个元素交换,获得最小元素。

  3. 接着将剩余无序序列,调整成小顶堆,重复步骤2,获得每一次调整后的最小值

  4. 直到调整到根,从而获得排序序列

堆排序(详情讲解)_第3张图片

6.0堆排序:算法

  • 代码
//【算法7.12】 堆排序算法
public void heapSort() {
   // System.out.println("堆排序");
    int n = this.curlen;
    RecordNode temp;
    for (int i = n / 2 - 1; i >= 0; i--) {//创建堆
        sift(i, n);
    }
    System.out.println("堆构建完成");
    for (int i = n - 1; i > 0; i--) {//每趟将最小值交换到后面,再调整成堆
        temp = r[0];
        r[0] = r[i];
        r[i] = temp;
        sift(0, i);
    }
}
  • 测试
public class TestSeqList12_heap {
    public static void main(String[] args) throws Exception {
        int[] arr = {33,25,46,13,58,95,18,63};
        SeqList seqList = new SeqList(arr.length);
        System.out.print("序列号:\t\t");
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + i);
            seqList.insert(i, new RecordNode(arr[i]));
        }
        System.out.println();
        // 树形选择排序(锦标赛排序)
        seqList.heapSort();
    }
}
//树形选择排序(锦标赛排序)
//序列号:	    0  1  2  3  4  5  6  7
//sift  3..8   33 25 46 13 58 95 18 63
//sift  2..8   33 25 18 13 58 95 46 63
//sift  1..8   33 13 18 25 58 95 46 63
//sift  0..8   13 25 18 33 58 95 46 63
//堆构建完成
//sift  0..7   18 25 46 33 58 95 63 13
//sift  0..6   25 33 46 63 58 95 18 13
//sift  0..5   33 58 46 63 95 25 18 13
//sift  0..4   46 58 95 63 33 25 18 13
//sift  0..3   58 63 95 46 33 25 18 13
//sift  0..2   63 95 58 46 33 25 18 13
//sift  0..1   95 63 58 46 33 25 18 13

7.0性能分析

  • 空间复杂度:需要一个记录辅助存储空间,O(1)

  • 最坏时间复杂度:O(nlog2n)

  • 堆排序是==不稳定==的排序算法。

 

你可能感兴趣的:(算法)