数据结构之堆(Heap)及其用途

最新推荐文章于 2024-07-24 18:19:29 发布

热情de马金

最新推荐文章于 2024-07-24 18:19:29 发布

阅读量1.2w

点赞数 14

分类专栏：数据结构文章标签：数据结构 heap 结构

本文链接：https://blog.csdn.net/a1459268562/article/details/53509548

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文采用图文码结合的方式介绍堆来实现优先队列

什么是优先队列？
队列是一种先进先出(FIFO)的数据结构。虽然，优先队列中含有队列两个字，但是，他一点也不像队列了。个人感觉，应该叫他优先群。怎么说那，一群守秩序(FIFO)的人去排队买东西当然是队列结构。但是，一群不守秩序的人去买东西，当然谁的拳头大谁就先结账。这个拳头的大小就是我们所谓的优先级。哎~我拳头不大~
优先队列的实现方式有：
1.线性表
2.堆(Heap)
3.左高树(Leftist Tree)

本文先从堆(Heap)开始讨论实现优先队列。

介绍堆之前，先介绍一种叫做最大树和最小树的数据结构：
最大（小）树：
1.根的值大（小）于等于所有子树中所有的值
2.子树也是最大（小）树

最大（小）堆:
1.完全二叉树 2.最大（小）树

首先，我们要清楚，最大堆中最大的元素一定出现在根上，最小的元素一定在树的叶子上；第二大的元素一定在第二层上等等。
其次，因为堆是完全二叉树，所以，使用数组描述这种结构最好不过了。

一个最大堆
上图是一棵最大堆。
我们想对这中数据结构进行插入、删除时，要如何完成？
插入（就是拉父亲，拉不拉得动就另一说了）：
1)当插入5时，因为完全树，所以5要出现在第四层的第三个位置上。5放到这之后，父元素仍然比他大，所以仍然可以构成堆。
插5以后的结果
2)当插入20时，同样，要出现在4层的第三个上。但是，这时，7比20小了，那么，就把7拿下来，在判断20是不是可以在原7的位置上，不行的话，往下拉父节点，去侵占父节点的位置。
要插入20
第一次拉父
第二次拉父
第三次拉父
插入时，每一层操作一次，最多操作height次
于是时间复杂度为O( $log_2n$ )

删除（当然是要删最大的元素了，也就是要删根）：

这也是一个最大堆

删掉20时，我们首先由完全树的定义知，第4层的8的未知将消失，我们不妨把8先拿到根上，再进行堆的重构（在左右树都是堆的情况下）。
第一步
第二步
第三步
删除时，每一层最多被修改一次，于是最多修改height次。
时间复杂度时O( $log_2n$ )。

最大堆的初始化（对数组中的元素进行调序）：
想一下最大堆，我们要想调序，要从最下层开始，但是，叶子需要调吗？暂时不需要。一个单独的节点就可以看成是一个最大堆了。由最大堆的性质可知，后面 $\lceil n/2\rceil$ 个元素是叶子。那么，我们就从第[n/2]个元素开始对其进行调序。

对数组{1,2,3,4,5,6,7,8,9,10,11}进行调序
初始化
叶子暂时是不需要重构的。从5开始，对5进行重构和上面的重构方法类似不赘述。对4重构、3、2、1。

分析时间复杂性：
对第i层的某元素进行重构时，最复杂就是从这个元素到叶子上的一条路径的节点都被修改，时间复杂度为O(height-i+1)。
我们一共需要修改height-1层；且第i层最多有 $2^{i-1}$ 个元素。
于是，总时间复杂度为
O( $(height-i+1)*(height-1)*2^{i-1}\quad\forall i\in\mathbb {1,2,3,...,height-1}$ )=O( $2^h$ )=O(n)

============================================================================

古人云：“没有代码就是耍流氓。” 代码如下：

/*MaxHeap*/
#include"xcept.h"
#include<iostream>
using namespace std;

template<class T>
class MaxHeap{
public:
    MaxHeap(int _maxsize=10);
    ~MaxHeap(){  delete[] heap; };
    MaxHeap<T>& Insert(T& t);//将元素t插入最大堆
    MaxHeap<T>& Delete(T& t);//将最大堆的根删掉，返回到t中
    void Initialize(T t[], int _currSize, int _maxSize);//初始化最大堆
    void output();
    void Deactive();
private:
    int currentSize;
    int maxSize;
    T *heap;//数组存放
};
template <class T>
MaxHeap<T>::MaxHeap(int _maxsize){//构造函数
    currentSize = 0;
    maxSize = _maxsize;
    heap = new T[maxSize + 1];//第一个元素不使用
}
template <class T>
MaxHeap<T>& MaxHeap<T>::Insert(T& t){//将元素t插入最大堆
    if (currentSize == maxSize) //满了拒绝插入
        throw NoMem();
    int i = ++currentSize;
    while (i != 1 && t > heap[i / 2]){
        heap[i] = heap[i / 2];//拉下父亲来
        i = i / 2;
    }
    heap[i] = t;
    return *this;
}

template <class T>
MaxHeap<T>& MaxHeap<T>::Delete(T& t){//删除最大元素
    if (currentSize == 0){//堆是空的，拒绝
        throw OutofBounds();
    }
    t = heap[1];
    T tail = heap[currentSize--];

    //重构
    int i = 1;
    int ci = 2;//记录i的孩子
    while (ci<=currentSize)
    {
        //找最大的孩子
        if (ci<currentSize && heap[ci+1]>heap[ci]){
            ci = ci + 1;
        }
        //判断是不是可以在当前位置i
        if (tail > heap[ci]){//yes
            break;
        }
        //no
        heap[i] = heap[ci];//把最大的孩子拿上去

        i = ci; //判断位置下移
        ci = i * 2;//仍记录孩子
    }
    heap[i] = tail;
    return *this;
}
template <class T>
void MaxHeap<T>::Initialize(T t[], int _currSize, int _maxSize){
    delete[]heap;
    heap = t;
    maxSize = _maxSize;
    currentSize = _currSize;

    //重构
    for (int i = maxSize / 2; i > 0; i--){
        T data = heap[i];//对第i个元素进行重构
        int ci = i * 2;
        while (ci <= currentSize)
        {
            //找最大的孩子
            if (ci<currentSize && heap[ci + 1]>heap[ci]){
                ci = ci + 1;
            }
            //判断是不是可以在当前位置i
            if (data > heap[ci]){//yes
                break;
            }
            //no
            heap[ci/2] = heap[ci];//把最大的孩子拿上去

            //判断位置下移
            ci = ci * 2;//仍记录孩子
        }
        heap[ci/2] = data;
    }

}
template<class T>
void MaxHeap<T>::Deactive(){
    heap = 0;
}
template<class T>
void MaxHeap<T>::output(){
    for (int  i = 1; i <= currentSize; i++)
    {
        cout << heap[i] << " ";
    }
    cout << endl;
}

class NoMem{
public :
    NoMem(){}
};
class OutofBounds{
public:
    OutofBounds(){

    }
};

这样，我们保证了每次出”队列”的都是最大的元素。即有了优先性。

========================================================================
堆这种基本的出入模式，可以完成一个人人皆知的排序算法—-堆排序。这是一种排序快且稳定的算法。

用堆来实现排序，看下面的代码：

#include"MaxHeap.h"
template <class T>
void heapSort(T arr[],int currSize,int maxSize){
    MaxHeap<T> mh;
    mh.Initialize(arr, currSize, maxSize);
    for (int i = currSize; i >0; i--)
    {
        T temp;
        mh.Delete(temp);
        arr[i] = temp;
    }
    //不让mh删掉arr
    mh.Deactive();
    for (int i = 1; i <= currSize; i++)
    {
        cout << arr[i] << " ";
    }
}

调用

//第一个位置不放元素
    int x[20] = {0,4,2,3,8,9,1,5};
    heapSort(x, 7, 20);

结果

分析一下时间复杂度：
创建最大堆：n
删掉一个元素： $log_2n$
删掉全部的元素： $n*log_2n$
总的操作次数： $n+n*log_2n$
则总的时间复杂度****O( $nlogn$ )（这是最快的排序了吧，好像是）

================================================================

同样，我们也可类似的给出最小堆的生成方法。

使用最小堆结构我们还可以实现一个特殊的树结构–哈弗曼树(Haffman Tree)。
哈弗曼树可以用来给文本压缩、也可以解决一些优化问题。介绍一下文本的压缩吧，其实压缩就是一种特殊的优化。

有一个文本若是由1000个字符组成，且字符只有a、b、c、d组成，那就有1000个字节，即8000位数据。
若是将a表示成00,b表示成01,c表示成10,d表示成11。那么，我们表示这一个文件只需要2000位，即250字节就可以表示。节省了四分之三的空间，是不是很爆炸。

那我们要是把编码改成a:0、b:1、c:00、d:01，是不是可以那，要是可以那我们这样来编码是不是更省空间啊。看下面的例子：
abaccd=>010000001，这是将文本压缩的方式，但是我们能不能从这种编码将文本解压缩回去啊？010000001=>?显然是不能的。
那么，我们就需要对编码进行限制，任意编码不能是其他编码的前缀。于是，二叉树这种结构就很好用了，将节点前往左孩子的路径上标0，前往右孩子的路径上标1，因为任意两个叶子的路径一定不会是前缀的关系。但是，有四个叶子的二叉树的结构有很多，我们要选择哪种啊？不难想，我们要是尽量把文本压缩的小，那么我们就要让出现越多的字符替换的长度越短。于是，我们要统计文本中的各个字符的数目。于是，我们就需要来决定每个不同频率字符在树中的位置了。

我们给出haffman tree树的定义：
记WEP为加权外部路径的长度。L(i)跟根到外部节点i的距离，F(i)到外部节点的i的权值（也就是我们的频率）。

W E P = \sum i = 1 n L (i) * F (i)

$WEP=\sum_{i=1}^n L(i)*F(i)$
haffman tree就是对给定的频率建立的最小加权外部路径长度的二叉树。

进行文本压缩：
1.确定文本的字符数目。
2.构建字符对应的haffman tree
3.确定字符对应的haffman 编码
4.使用haffman 编码进行压缩

简单介绍一下如何构建一棵haffman tree：
1.将每一个字符建成二叉树的外部节点。
2.选取两棵权值最小的树进行合并。新树的权值为两个小树的权值之和。
3.重复2,直至剩下一棵树。

haffman tree的构建
最终结果

于是：我们可以得到haffman 编码
a:00
b:010
c:011
d:100
e:101
f:11

实现代码：

#Haffman.h#

#include"MinHeap.h"
#include"BinaryTree.h"
#include "Stack.h"
class HaffmanNode{
    //一个haffman tree的节点包含权值和二叉树
public:
    bool operator>(HaffmanNode& a){
        if (weight > a.weight)
            return true;
        else
            return false;
    }
    bool operator<(HaffmanNode& a){
        if (weight < a.weight)
            return true;
        else
            return false;
    }
    int weight;//权值
    BTree<int> btree;//二叉树
};
//创建haffman树
BTree<int>& haffman(int a[], int n){
    //a[1...n]为每一个字符的权值，n为有几个字符
    HaffmanNode *hnodes = new HaffmanNode[n + 1];//从第一个开始使用
    BTree<int> treeInHaff,zero;
    //将每个节点初始化成一个带权的haffman树
    for (int i = 1; i <= n; i++)
    {
        treeInHaff.makeTree(1,zero,zero);//1没有意义随便写
        hnodes[i].weight = a[i];
        hnodes[i].btree = treeInHaff;
    }

    //存放haffman树的最小堆，用来找最小的haffman树
    MinHeap<HaffmanNode> t(1);
    t.Initialize(hnodes, n, n);
    //合并两个最小haffman树,n个元素进行n-1次的合并
    for (int i = 1; i <n; i++)
    {
        //找出两个最小的
        HaffmanNode temp1;
        t.Delete(temp1);
        HaffmanNode temp2;
        t.Delete(temp2);

        //对这两棵树进行合并操作
        int data = temp1.weight + temp2.weight;
        treeInHaff.makeTree(1,temp1.btree, temp2.btree);//1没有意义，随便写

        HaffmanNode opResult;//两颗最小的树的合并结果
        opResult.btree = treeInHaff;
        opResult.weight = data;
        t.Insert(opResult);//一定要存回
    }
    HaffmanNode lastTree;
    //最后的一颗树就是结果
    t.Delete(lastTree);
    return lastTree.btree;
};

//显示构造的haffman tree的haffman编码
void show(BTNode<int> *t,Stack<int>& s){
    if (t)
    {
        //当左右都变成空了，我们就输出这时的01序列
        if (!t->lchild && !t->rchild)
        {
            s.showStatus();
        }
        else {
            s.push(0);//进入左孩子，标0
            show(t->lchild, s);
            int x;
            s.pop(x);
            s.push(1);//进入右孩子，标1
            show(t->rchild, s);
            s.pop(x);
        }

    }
}

#MinHeap.h#

#include<iostream>
using namespace std;

template<class T>
class MinHeap{
public:
    MinHeap(int _Minsize = 10);
    ~MinHeap(){ delete[] heap; };
    MinHeap<T>& Insert(T& t);//将元素t插入最大堆
    MinHeap<T>& Delete(T& t);//将最大堆的根删掉，返回到t中
    void Initialize(T t[], int _currSize, int _maxSize);//初始化最大堆
    void Deactive();//heap = 0
private:
    int currentSize;
    int maxSize;
    T *heap;//数组存放
};
template <class T>
MinHeap<T>::MinHeap(int _maxsize){//构造函数
    currentSize = 0;
    maxSize = _maxsize;
    heap = new T[maxSize + 1];//第一个元素不使用
}
template <class T>
MinHeap<T>& MinHeap<T>::Insert(T& t){//将元素t插入最大堆
    if (currentSize == maxSize) //满了拒绝插入
        throw NoMem();
    int i = ++currentSize;
    while (i != 1 && t < heap[i / 2]){
        heap[i] = heap[i / 2];//拉下父亲来
        i = i / 2;
    }
    heap[i] = t;
    return *this;
}

template <class T>
MinHeap<T>& MinHeap<T>::Delete(T& t){//删除最大元素
    if (currentSize == 0){//堆是空的，拒绝
        throw OutofBounds();
    }
    t = heap[1];
    T tail = heap[currentSize--];

    //重构
    int i = 1;
    int ci = 2;//记录i的孩子
    while (ci <= currentSize)
    {
        //找最小的孩子
        if (ci<currentSize && heap[ci + 1]<heap[ci]){
            ci = ci + 1;
        }
        //判断是不是可以在当前位置i
        if (tail < heap[ci]){//yes
            break;
        }
        //no
        heap[i] = heap[ci];//把最小的孩子拿上去

        i = ci; //判断位置下移
        ci = i * 2;//仍记录孩子
    }
    heap[i] = tail;
    return *this;
}
template <class T>
void MinHeap<T>::Initialize(T t[], int _arrCurr, int _arrMax){
    //_arrCurr传进数组的当前下标，_arrMax最大下表
    delete[]heap;
    heap = t;
    maxSize = _arrMax;
    currentSize = _arrCurr;

    //重构
    for (int i = maxSize / 2; i > 0; i--){
        T data = heap[i];//对第i个元素进行重构
        int ci = i * 2;
        while (ci <= currentSize)
        {
            //找最小的孩子
            if (ci<currentSize && heap[ci + 1]<heap[ci]){
                ci = ci + 1;
            }
            //判断是不是可以在当前位置i
            if (data < heap[ci]){//yes
                break;
            }
            //no
            heap[ci / 2] = heap[ci];//把最小的孩子拿上去

            //判断位置下移
            ci = ci * 2;//仍记录孩子
        }
        heap[ci / 2] = data;
    }

}
template<class T>
void MinHeap<T>::Deactive(){
    heap = 0;
}

#BinaryTree.h#

template<class T>
class BTNode{
public:
    BTNode(){ data = 0; lchild = 0; rchild = 0; }
    BTNode(T _data, BTNode *_lchild, BTNode *_rchild){ data = _data; lchild = _lchild; rchild = _rchild; }
    T data;
    BTNode *lchild;
    BTNode *rchild;
};
template <class T>
class BTree {
public:
    BTree(){ root = 0; }
    void makeTree(const T& data, BTree<T> &l, BTree<T> &r){
        root = new BTNode<T>(data, l.root, r.root);
        l.root = 0; r.root = 0;
    };
    BTNode<T> *root;
};

#stack.h#

#include<iostream>
using namespace std;
/*
使用数组来实现Stack
*/
template<class T>
class Stack{
public:
    Stack(int maxtop=20);
    ~Stack(){ delete[] element; }
    bool isEmpty(){ return _top == -1; };
    bool isFull(){ return _top == MaxTop - 1; };
    Stack<T>& push(const T& t);//入栈
    Stack<T>& pop(T& r);//出栈
    void showStatus();//显示栈的元素，从栈低
private:
    int _top; //记录栈顶的位置
    int MaxTop;//记录总的栈的大小
    T *element;//存放元素
};

template<class T>
Stack<T>::Stack(int maxtop){//构造函数
    element = new T[maxtop];
    MaxTop = maxtop;
    _top = -1;
}

template<class T>
Stack<T>& Stack<T>::push(const T& t){//入栈
    if (isFull())throw OutofBounds();
    _top++;
    element[_top] = t;
    return *this;
}
template<class T>
Stack<T>& Stack<T>::pop(T& r){//出栈
    if (isEmpty()) throw OutofBounds();
    r = element[_top];
    _top--;
    return *this;
}
template<class T>
void Stack<T>::showStatus(){
    //显示栈的元素,从栈低开始显示
    //因为我们是从根开始往里放的，那么，我们就要从下往上输出
    for (int i = 0; i <= _top; i++){
        cout << element[i] << " ";
    }
    cout << endl;
}

#xcept.h#

//定义了两个异常类
class NoMem{
public :
    NoMem(){}
};
class OutofBounds{
public:
    OutofBounds(){}
};

测试代码：

#include"xcept.h"
#include<iostream>
using namespace std;
#include"HaffmanTree.h"
void main(){
    //第一个位置不放元素的权值，第一个元素的权值放在x[1]
    int x[7] = { 0,1,2,4,5,6,7};

    BTree<int> tree = haffman(x,6);
    Stack<int> s(20);
    show(tree.root, s);
}

测试结果：
haffman 编码的结果

经过上面的代码，我们能生成haffman编码了。
相信有了编码，对屏幕前的你来说不能实现压缩了。

==============================================================================
那么，我们想使用haffman树来解决优化问题也很简单，只需要把数组中的权值换成你要解决问题的权值（这个权值可能是需要你用一定的运算来算出）。我们就不对优化详细介绍了，因为，haffman编码的生成实际实际上就是优化问题。