堆排序

参考自：链接: link

1 概念

1） 堆的基本概念
堆 是一种特殊的树，满足以下条件即为堆：

• 首先堆是一个完全二叉树
• 堆中每一个节点的值都必须大于等于（或小于等于）其左右子节点的值
• 每个节点都大于等于其子树节点的堆叫“大顶堆“或大根堆，根是最大值
• 每个节点都小于等于其子树节点的堆叫“小顶堆“或小根堆，根是最小值

因为堆的要求不像二叉搜索树那么严格。他只要求某个节点的子节点大于或小于该节点，因此同一组数据，可以构建多种不同形态的堆：

2）堆的表示
堆是完全二叉树，大部分时候都是使用数组来存储堆

规律（根节点是0号）

• i 结点的父结点 par = floor((i-1)/2) 「向下取整」

• i 结点的左子结点 2 * i +1

• i 结点的右子结点 2 * i + 2

因为堆是完全二叉树，所以说，数组中的元素的父节点、孩子节点都是可以用公式算出来的！（层序遍历下）

2 堆的操作

堆的操作主要有两种：插入、删除。。（priority_queue也正是只提供了这两种方法）

不管是插入还是删除后都有可能不再满足堆的定义即：

• 堆是一颗完全二叉树

• 堆中每个节点都必须大于等于（或小于等于）其左右子节点

在插入或删除操作后需要进行调整，让其重新满足堆的特性，这个调整的过程叫做堆化（heapify）

1） 两种堆化方式

从下往上（上浮）：当前元素不断向上和父节点比较大小：

• 大顶堆：当前元素比父节点大，交换，让大的节点上去
• 小顶堆：当前元素比父节点小，交换，让小的节点上去

从上往下（下沉）：当前元素不断向下和两个孩子节点比较大小

• 大顶堆：当前元素与子节点中较大的比，比子节点小交换，让小的节点下去
• 小顶堆：当前元素与子节点中较小的比，比子节点大交换，让大的节点下去

当根节点是0号的时候，下沉和上浮代码是：

//模拟priority_queue
class Heap
{
    
private:
    vector<int> vec;
    int capacity;
    int count;


    void swapNode(int i,int j)
    {
    
        swap(vec[i],vec[j]);
    }

    //小根堆的上浮操作---在堆中将index节点上浮
    void siftup_minheap(int index)
    {
    
        int parentNode=(index-1)/2;
        while(parentNode>=0)
        {
    
            if(vec[parentNode]<vec[index])
                break;//父节点比这个节点小，则停止上滤
            
            swapNode(index,parentNode);
            index=parentNode;
            parentNode=(index-1)/2;

        }
    }


    //小根堆的下沉操作--下沉的范围是[index,n),一般是vec.size()
    void siftdown_minheap(int index,int n)
    {
    
        int i=index;
        int j=2*i+1;//index节点的左儿子
        while(j<n)
        {
    
            if(j+1<n && vec[j+1]<vec[j]) j++;//j是左儿子和右儿子。较小的那个的下标
            if(vec[i]<vec[j]) break;//如果 当前节点比两个孩子都要小，那么停止下沉
            swapNode(i,j);
            i=j;
            j=2*i+1;
        }
    }



};

2） 插入

插入的过程是从下往上的堆化：在堆的尾部插入，以满足完全二叉树条件，再进行堆化。

过程：

• 让新插入的节点与父节点对比大小。如果新插入的节点大于父节点，我们就互换两个节点。一直重复这个过程，直到满足堆的条件。

java代码如下：

 void del()
    {
    
        int n=vec.size();
        swapNode(0,n-1);

        vec.pop_back();

        siftdown_minheap(0,vec.size());

    }

3） 删除堆顶元素

堆的删除操作，往往是删除堆顶的元素
删除非堆顶元素的效率不高，意义通常也不大。

删除堆顶元素，过程是从上往下的堆化。

堆顶元素存储的就是堆中数据的最大值或者最小值。删除了堆顶元素后，可以把最后一个元素移到根节点的位置，满足完全二叉树的条件，再进行堆化

最后一个节点放到堆顶，在子节点中找出较大(大顶堆)的那个对比。小于子节点时，互换两个节点，并且重复进行这个过程。这就是从上往下的堆化方法。

java代码如下：

//删除顶部元素
removeMax() {
    
  if (count == 0) return -1; // 堆中没有数据
  a[1] = a[count];//最后一个元素移到根节点的位置
  --count;
  sink(a, count, 1); 
}
// 自上往下堆化
sink(a, n, i) {
     
  while (true) {
    
    const maxPos = i;
    if (i*2 <= n && a[i] < a[i*2]) maxPos = i*2;
    if (i*2+1 <= n && a[maxPos] < a[i*2+1]) maxPos = i*2+1; // 需要在两个子节点中找大的出来
    if (maxPos == i) break;
    swap(a, i, maxPos);
    i = maxPos;
  }
}

3） 堆化时间复杂度
堆化的过程是顺着节点所在路径比较交换的，所以堆化的时间复杂度跟树的高度成正比，也就是 O(logn)。

4）插入和删除时间复杂度

插入数据和删除堆顶元素的主要逻辑就是堆化，所以时间复杂度都是 O(logn)。

3 堆排序

堆排序步骤

• “大顶堆”用于升序排列

• “小顶堆”用于降序排列

实现堆排序可分解为两个步骤，建堆和排序

1）建堆

数组原地建成一个堆。所谓“原地”就是，不借助另一个数组，就在原数组上操作

方式一（从前往后处理数组）

从前往后依次处理数组元素，数据插入堆中时，都用从下往上堆化。直到最后一个元素处理完成。

假设，起初堆中只包含一个数据，就是index=1 的元素6

• Step1：6这个元素，只有一个，不需要比较；
• Step2：调用前面讲的插入操作，将index=2的元素8插入堆中。
  堆化：这里8大于堆顶6，堆化后8与6交换位置
• Step3：将index=3的元素3插入堆中。
  堆化：这里3小于index 3/2=1的位置上的元素8，不需要交换；
• Step4：将index=4的元素10插入堆中。
  堆化：这里10大于index 4/2=2上的元素6，交换，再与index=2/2=1上的8比，比8大，交换
• Step5：……
• Step6：将index从 2 到 n 的数据依次插入到堆中，完成建堆。

除了第一个节点，都需要堆化。即对n-1个节点进行了堆化。时间复杂度是NlogN。（需要复杂的公式推导，记住就行了）

这个过程，虽然是原地操作，往往，我们会有下面这种情况：
给定一个数组，遍历这个数组，往一个priority_queue中插入元素。
这个过程，本质上就是方式一的方法，也就是在原地在数组中从前往后调整，所以时间复杂度也是NlogN。（往prirotity——queue中插数据，本质上就是差插到pri_queue底部的那个数组的末尾，然后上浮。）

方式二（从后往前处理数组）

从后往前处理数组，使用从上往下堆化，直到第一个元素处理完成。

对于完全二叉树来说，叶子节点：

• 根节点是1开始编号的时候，下标从 n/2+1 到 n 的都是叶子节点。所以第一个非叶子节点为n/2
• 根节点是0开始编号的时候，第一个非叶子节点是最后一个节点的父节点，也就是（n-1-1）/2=(n-2)/2

叶子节点往下堆化只能自己跟自己比较，所以从最后一个非叶子节点index=4开始堆化

• Step1：index=4的元素8小于子节点16，交换位置
• Step2：index=3的元素19小于子节点20，交换位置
• Step3：index=2的元素5小于子节点16，交换位置，再次小于子节点13，交换位置
• Step4：index=1的元素7小于子节点20，交换位置，再次小于子节点19，交换位置。完成建堆。

下标从 n/2 开始到 1 的节点进行堆化。

结论:

• 对比方式一的n-1个节点堆化，采用从后往前处理数组的方式较好

时间复杂度:因为叶子节点不需要堆化，所以需要堆化的节点从倒数第二层开始，每个节点堆化的过程中，需要比较和交换的节点个数是与它的高度k成正比的。

建堆的时间复杂度是 O(n)

2）排序
排序是建立在已经构建一个堆的基础上的。数组中的第一个元素就是堆顶，也就是最大或最小的元素。我们可以利用删除堆顶元素的思路来进行堆排序。

• Step1:将堆顶元素9与第n个元素(index=5)交换，此时最大值位于5(数组最后位)，下标为5的元素位于堆顶
  堆化：5小于子节点中较大的6，与6交换位置

• Step2: 再取此时的堆顶元素6 与n-1个元素(index=4)交换
  堆化：1小于子节点中较大的5，与5交换位置

• Step3: 再取堆顶元素5 与n-2个元素(index=3)交换
  堆化：3大于子节点1，不交换

• Step4: 再取堆顶元素3 与n-3个元素(index=2)交换

• Step5: 再取堆顶元素1，发现没有可比较的子节点了，堆排序结束

排序过程中需要对n个元素进行堆化，堆化的时间复杂度是O(logn)，所以排序过程的时间复杂度是 O(nlogn)

排序结果：

• 大顶堆：升序数组
• 小顶堆：降序数组

堆排序复杂度
时间复杂度：堆排序包括建堆和排序两个操作，建堆过程的时间复杂度是 O(n)，排序过程的时间复杂度是 O(nlogn)，所以，堆排序整体的时间复杂度是 O(nlogn)

空间复杂度：排序不需要占用额外的空间，只需要交换元素的需要一个临时变量，所以堆排序的空间复杂度为O(1)。

4堆应用

1）优先级队列就是使用的堆封装的
2）其他应用见参考：https://juejin.cn/post/7007610680891146271

5 代码

#include<vector>
#include<iostream>
using namespace std;

//模拟priority_queue
class Heap
{
    
public:
    vector<int> vec;
    int capacity;
    int count;


    void swapNode(int i,int j)
    {
    
        swap(vec[i],vec[j]);
    }

    //小根堆的上浮操作---在堆中将index节点上浮
    void siftup_minheap(int index)
    {
    
        if(index==0) return;
        cout<<"..."<<endl;
        int parentNode=(index-1)/2;
        while(parentNode>=0)
        {
    
            
            if(vec[parentNode]<vec[index])
                break;//父节点比这个节点小，则停止上滤
            
            swapNode(index,parentNode);
            index=parentNode;
            if(index==0) break;
            parentNode=(index-1)/2;

        }
    }


    //小根堆的下沉操作--下沉的范围是[index,n),一般是vec.size()
    void siftdown_minheap(int index,int n)
    {
    
        int i=index;
        int j=2*i+1;//index节点的左儿子
        while(j<n)
        {
    
            if(j+1<n && vec[j+1]<vec[j]) j++;//j是左儿子和右儿子。较小的那个的下标
            if(vec[i]<vec[j]) break;//如果 当前节点比两个孩子都要小，那么停止下沉
            swapNode(i,j);
            i=j;
            j=2*i+1;
        }
    }

    //小根堆的插入操作
    void insert(int num)
    {
    
        vec.push_back(num);
        int index=vec.size();
        siftup_minheap(index-1);
    }

    //小根堆的删除堆顶元素操作--先将根节点和末尾元素互换，然后popback，然后从根节点开始下沉
    void del()
    {
    
        int n=vec.size();
        swapNode(0,n-1);

        vec.pop_back();

        siftdown_minheap(0,vec.size());

    }

    //原地建堆的操作--复杂度是NlogN
    void  buildHeap_1()
    {
    
        for(int i=0;i<vec.size();i++)
        {
    
            siftup_minheap(i);
        }
    }



    //时间复杂度是N的，建堆方法--从第一个非叶子节点，往前遍历，并进行下沉操作
    void buildHeap()
    {
    
        int n=vec.size();
        for(int i=(n-2)/2;i>=0;i--)
        {
    
            siftdown_minheap(i,vec.size());
        }
    }


    int top()
    {
    
        int temp=vec[0];
        return temp;
    }


public:

    Heap(vector<int>& vec_)
    {
    
        vec=vec_;
    }

};

int main()
{
    
    vector<int> vec{
    9,4,7,1,5,3};
    Heap heap_(vec);
    heap_.buildHeap();

    while(heap_.vec.size()>0)
    {
    
        cout<<heap_.top()<<endl;
        heap_.del();
    }

    return 0;

}