数据结构复习笔记——排序（堆排序）

排序算法概述

1. 排序目的：便于查找。
2. 排序算法好坏的衡量指标：时间效率（时间复杂度、比较次数），空间效率（空间复杂度、占内存辅助空间大小），稳定性（关键字值相等的记录A和B在排序后先后次序不变则稳定）
3. 内部排序概念：待排序记录都在内存中。
   外部排序概念：待排序记录一部分在内存，一部分在外存（硬盘等）。

排序分类

1. 按排序规则不同分为：
   插入排序
   交换排序
   选择排序
   归并排序
   基数排序
2. 按时间复杂度不同分为：
   简单排序 O(n²)
   先进排序 O(nlog₂n)
   基数排序 O(d*n) ——其中d=关键字的位数

堆排序

因为最近在刷leetcode的时候多次遇到使用堆排序解决的题目，所以特别写在笔记里，一劳永逸。

概念

堆排序是由1991年的计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特.弗洛伊德(Robert W．Floyd）和威廉姆斯(J．Williams）在1964年共同发明了的一种排序算法（ Heap Sort )；

1. 概念：大顶堆和小顶堆（也叫大根堆和小根堆）。
2. 定义：堆的定义：设有n个元素的序列 k1，k2，…，kn，当且仅当满足下述关系之一时，称之为堆。

大顶堆：

当用一位数组存储这个序列，就是在一个完全二叉树中，所有父节点比它的子节点都要大。根节点的值最大。

小顶堆：（略）

方法

描述：设有n个元素，将其按关键码排序。首先将这n个元素按关键码建成堆，将堆顶元素输出，得到n个元素中关键码最小(或最大)的元素。然后，再对剩下的n-1个元素建成堆，输出堆顶元素，得到n个元素中关键码次小(或次大)的元素。如此反复，便得到一个按关键码有序的序列。称这个过程为堆排序。

概括：
1.先对元素序列整理成堆。
2.将首尾元素互换位置，即交换完全二叉树中根节点与最后一个叶子节点之间的位置。
3.将剩下的n-1个元素视为一个完全二叉树并整理成堆。以此循环，直到二叉树只剩一个根节点。

需要解决的问题有两个：
1.将n个元素的序列整理成堆。
2.调整后n-1个元素的序列整理成堆。
（思考1：为什么要建堆？要排序的话，每次把最大或者最小值找到并拎出来不就好了吗？为什么要把整体结构都弄成堆的格式？）

问题1 初始建堆方法（以建大根堆为例）：

• 因为叶子节点没有子节点，所以不存在它小于子节点的情况，不需要调整。所以要从最后一个非叶子节点开始从后往前逐个调整非叶子节点。（思考2：为什么是从后往前而不是从前往后？）
• 根据完全二叉树的性质，若有n个节点，则最后一个非叶子节点的序号为⌊n/2⌋。（因为默认序列元素从1开始，所以序号为
  ⌊n/2⌋。通常在程序中，顺序表序号从0开始，此时最后一个一个非叶子节点的序号为⌊(n-1)/2⌋。）所以从以⌊n/2⌋为父节点的子树开始将整棵树整理成堆，即整理完以序号为⌊n/2⌋的元素为根的子树后，再整理以序号为⌊n/2⌋-1的元素为根的子树，一直整理到根节点。
• 在对以每个元素为根节点的子树进行整理时，如果出现max(左子，右子）大于目前子树的根节点，则需要将max(左子，右子）的值与根节点的值交换。然后再对以被交换的子节点为根节点的子树进行同样的操作，直到根节点为叶子节点或者根节点满足大于两个子节点的值的这一大根堆的性质。
• （思考3（补充思考1）：交换后为什么要向下再整理？既然已经从最后一个非叶子节点往前整理了，那最大值肯定能被送到最顶上啊，这不就是每次整理的目的吗？向下继续整理，把整个元素序列整理成堆有什么作用呢？）

问题2 剩余元素重新建堆

• 设当前剩余元素个数为m,因为元素个数为m+1时已经被整理成堆了，也就是说所有的父节点都要大于子节点。那么当那+1的根节点（最大元素）拿走，并把最后一个叶子节点放到根节点的位置后，势必会出现树被破坏的情况，但因为选取的是最后一个叶子结点，所以完全二叉树结构没有被破坏，因此可以继续整理建堆。

• 接着，从被破坏的地方（根节点）开始，进行一次整理（即问题1中的最后一段所述的过程），即可将m个元素再次整理成堆（根节点的值没有变化的子树是不用动的，因为在之前初始建堆或者上一轮m+1个元素建堆的时候已经被整理好了）。

• 重复流程，则顺序表会被逐渐整理成升序结构。

思考

• 思考1：为什么要建堆？要排序的话，每次把最大或者最小值找到并拎出来不就好了吗？为什么要把整体结构都弄成堆的格式？
  思考3（补充思考1）：交换后为什么要向下再整理？既然已经从最后一个非叶子节点往前整理了，那最大值肯定能被送到最顶上啊，这不就是每次整理的目的吗？向下继续整理，把整个元素序列整理成堆有什么作用呢？

  解答：如果不把整颗树整理成堆的话，也就是说会有子树不满足堆的性质。那么每一轮都要对所有的子树进行一轮比较，来把最值送上顶端，这样的时间复杂度还是O(n²)，本质上没有构建起下标与关键值之间的关系，也就失去了堆排序的意义。

• 思考2：为什么是从后往前而不是从前往后？

  解答：好像从第一个根节点往后来整理的话，有一定规则也能行，但是会相当麻烦，会浪费很多无用功。树这样的有递归规律的结构还是从最小的子树往前往上来整理最简单和快捷。

复杂度计算

这里引用其他网友的博客内容，地址为https://blog.csdn.net/yuzhihui_no1/article/details/44258297
(前两天自己试着算了一次弄明白过了，现在总结的时候就不再花时间算了）
概括：
空间复杂度O(1)，因为是就地排序。
时间复杂度包括两部分，一个是初始建堆一个是后续的n轮堆化。
初始建堆：O(n)
n轮重新堆化：O(nlog₂n)
所以总时间复杂度 = O(n)+O(nlog₂n) = O(nlog₂n)

应用

来自领扣，初级算法题，数组类。

题目：
给定一个整数数组，判断是否存在重复元素。

如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

解法：先排序（堆排序），在挨个比较。

代码：

public class Solution {
    public bool ContainsDuplicate(int[] nums) {
        int n = nums.Length -1;
        HeapSort(nums,n);
        
        for(int i = 0; i < n; i++){
            if(nums[i] == nums[i+1]) return true;
        }
        
        return false;
    }
    
    void HeapAdjust(int[] nums, int s, int m){
        int rc = nums[s];
        for(int j = 2*s + 1; j <= m; j = j*2 +1){
            if(j < m && nums[j] < nums[j+1]) j = j + 1;
            if(rc > nums[j]) break;
            else{
                nums[s] = nums[j];
                nums[j] = rc;
                s = j;
            }
        }
    }
    
    void HeapSort(int[] nums, int n){
        for(int i = (n-1)/2 ; i >= 0 ; i--) HeapAdjust(nums,i,n);
        for(int i = n; i > 0; i--){
            int ex = 0;
            ex = nums[0];
            nums[0] = nums[i];
            nums[i] = ex;
            HeapAdjust(nums,0,i-1);
        }
        
    }
}