数据结构算法Review1_堆

首先堆的本质是一个棵完全二叉树；

什么是二叉树、满二叉树、完全二叉树？见链接

树、二叉树（满二叉树、完全二叉树）概念：https://blog.csdn.net/sinat_41144773/article/details/89530403

最大堆（大顶堆）：顶结点最大，父亲结点比孩子结点大；

最小堆（小顶堆）：顶结点最小，父亲结点比孩子结点小；

堆一般都是vecotor或者数组作为实际存储的结构；

由于是完全二叉树，所以父亲结点和孩子结点的索引存在一些关系。

假设我们的堆是用数组存放的；i表示数组索引；

为了方便计算，i=0下标不存放任何数据。从i=1下标开始存放数据。

parent(i) = i/2;          //加入孩子结点的索引是i，父亲结点索引是i/2；

leftchild(i) = i*2;       // i是父亲结点的索引

rightchild(i)=i*2+1;   //i*2+1<=count; count是总结点数；

如果是i=0也存放数据的话。处理起来会麻烦一些。

parent(i) = (i-1)/2;

leftchild(i) = 2*i+1;

rightchild(i) = 2*i+2;   //i*2+2<=count-1; count是总结点数；

上面这些规律完全不用记，需要的时候画一个完全二叉树，简单推算一下即可。

接下来讲讲核心思路：

堆有三个核心操作： //方便起见，这里以最大堆为例

1、堆排序：给定一个数组或vector，如何把这个数组或vector变成一个最大堆？

　　这个过程是堆化的过程，或者是建堆的过程；

2、取出堆顶元素：

　　　　堆顶元素取出来后，如何继续保证这个堆是一个最大堆？

　　　　思路就是将堆的最后一个节点的值（即完全二叉树的最后一层，从左往右数最后一个节点）与堆顶节点的值进行交换；

　　　　该节点跑到的堆顶，之后就是不断向下，使用shiftdown操作。将该节点元素不断往下交换，直到寻找到合适的位置，以维持最大堆的定义；

3、插入一个新元素：

　　　　一般插入到队尾，然后不断向上，即使用shiftup操作。往上进行交换操作，也是直到寻找到合适的位置，以维持最大堆的定义；

实际上核心过程就是shiftdown、shiftup、和建堆；

建堆（堆排序）时间复杂度，可参考链接：

建堆的时间复杂度计算：https://blog.csdn.net/wangqing_199054/article/details/20461877

自下而上建堆的时间复杂度：https://www.cnblogs.com/zuotongbin/p/10702001.html

【算导】建堆过程时间复杂度为O（n）：https://www.jianshu.com/p/f2ab13f951c9

 

#include <iostream>
#include <cassert>
#include <queue>
#include <stack>

using namespace std;

template <typename Item>
class MaxHeap{
private:
    Item* data;
    int count;
    int capacity;

    //往堆中插入新元素，一般插入到队尾
    //需要shiftUp来维持堆的定义
    void shiftUp(int k){
        while(k>1 && data[k/2]<data[k]){
            swap(data[k/2],data[k]);
            k = k/2;
        }
    }

    //优化后
    void shiftUp_Opt(int k){
        Item e = data[k];
        while(k>1 && data[k/2]<data[k]){
            data[k] = data[k/2];
            k /= 2;
        }
        data[k] = e;
    }

    //取出最大堆，堆顶元素后，需要shiftdown维持堆的定义。
    //将一个元素不断往下，直至找到合适的位置，维持堆的定义。
    void shiftDown(int k){
        while(2*k<=count){
            //j为要与k交换的元素编号
            int j = 2*k;
            //右孩子存在，且比左孩子大
            if(j+1<=count && data[j+1]>data[j])
                j++;
            if(data[j]<data[k]) break; //如果交换到头了，就直接break
            swap(data[j],data[k]);
            k = j; //更新k，继续往下一轮的交换
        }
    }

    //优化后
    void shiftDown_Opt(int k){
        Item e = data[k];
        while(2*k<=count){
            int j = 2*k;
            if(j+1<=count && data[j+1]>data[j]) j++;
            if( e > data[j]) break;
            data[k] = data[j];
            k = j;
        }
        data[k] = e;
    }


public:
    //构造一个空堆
    MaxHeap(int capacity){
        data = new Item[capacity+1];
        count = 0;
        this->capacity = capacity;
    }

    //构造函数，给定一个数组构造一个最大堆
    MaxHeap(Item arr[], int n){
        data = new Item[n+1];
        capacity = n;

        for(int i = 0; i<n; i++)
            data[i+1] = arr[i];
        count = n;

        //堆化核心代码
        for(int i = count/2; i>=1; i--)
            shiftDown(i);

    }

    ~MaxHeap(){
        delete[] data;
    }

    //往堆中插入元素
    void insert(Item item){
        assert(count+1<=capacity);
        data[count+1] = item;
        shiftUp(count+1);
        count++;
    }

    //取出最大元素
    Item extractMax(){
        assert(count >0);
        Item ret = data[1];
        swap(data[1], data[count]);
        count --;
        shiftDown(1);
        return ret;
    }

    //堆是否为空
    bool isEmpty(){
        return count == 0;
    }

    //堆中元素个数
    int size(){
        return count;
    }


};

//普通版本的堆排序，将所有元素依次添加到堆中，然后再将所有元素依次从堆中取出，即完成了排序；
//无论是创建堆的过程还是从堆中依次取出元素的过程，时间复杂度均为O(nlogn)
//整个堆排序的整体时间复杂度为（nlogn)
template <typename T>
void heapSort1(T arr[], int n){
    MaxHeap<T> maxHeap = MaxHeap<T>(n);
    for(int i = 0; i<n; i++)
        maxHeap.insert(arr[i]);
    for(int i = n-1; i>=0; i--)
        arr[i] = maxHeap.extractMax();
}

//借助heapify进行堆排序
template <typename T>
void heapSort2(T arr[],int n){
    MaxHeap<T> maxHeap = MaxHeap<T>(arr,n);
    for(int i = n-1; i>=0; i--)
        arr[i] = maxHeap.extractMax();
}