欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

堆的实现以及优先级队列

程序员文章站 2022-03-31 10:08:31
...

堆的概念

堆是将一组数据按照完全二叉树的存储顺序,将数据存储在一个一维数组中的结构。
堆有两种结构,一种称为大顶堆,一种称为小顶堆,如下图。
小顶堆:任意结点的值均小于等于它的左右孩子,并且最小的值位于堆顶,即根节点处。
大顶堆:任意结点的值均大于等于它的左右孩子,并且最大的值位于堆顶,即根节点处。

堆的实现以及优先级队列

既然是将一组数据按照树的结构存储在一维数组中,那么父子之间关系的建立就很重要了。
假设一个节点的下标为i。
1、当i = 0时,为根节点。
2、当i>=1时,父节点为(i - 1)/2

堆的实现

以下面这个例子来建堆,

堆的实现以及优先级队列

int arr[10] = {12,23,54,2,65,45,92,47,204,31}
arr.size() = 10;

先看一下一次调整:
1、int i = (size - 2)/2 = 4找到数组中的4号下标。
65大于其孩子,满足大堆性质,所以不用交换。
堆的实现以及优先级队列

2、i= i-1;然后用2和其孩子比较,2和204交换。交换之后满足大堆
堆的实现以及优先级队列

3、54和其孩子比较,54和92交换。交换之后满足大堆性质
堆的实现以及优先级队列

4、23和其孩子比较,23和204交换
堆的实现以及优先级队列
交换完之后,它的子树却不满足了,所以还需调整它的子树。
堆的实现以及优先级队列

5、12和204交换。
堆的实现以及优先级队列
因为每一次调整都可能会影响到你的子树不满足,所以当你修改了一个节点后,一定要再去判断它的子树还是否满足,即需要向下调整

插入

在堆中插入一个元素,因为本身堆是建好的,所以满足性质,插入一个在树的最后,只需要顺着这条支路做一次调整就好了,不过这次不需要向下调整了,因为父节点肯定是大于子节点的。
堆的实现以及优先级队列
如图,如果插入的节点大于它的父节点,发生交换是肯定不会影响其子树的,因为父节点本身就大于它的子节点,更何况交换后的节点是大于父节点的。所以,这里只需要一次简单的向上调整就可以完成。
堆的实现以及优先级队列

删除
因为堆本身就是一种特殊的结构,所以一般对堆中的数据进行操作都是针对堆顶的元素,即针对最大值或最小值,比如哈夫曼树就用堆的结构来实现,因为每次要找出最小的两个数。
所以我们删除的时候,一般也是删除堆顶那个最小或最大的值,但是如果直接删掉堆顶,整个堆的结构被破坏了,必须重现建堆,这样无疑效率非常低,所以采用将堆中最后一个元素和堆顶元素进行替换,然后删除堆中最后一个元素。
堆的实现以及优先级队列
这样进行替换删除后,以堆顶为根的树不满足堆的性质,只需要进行一次简单的向下调整即可。

下面是实现堆的代码,因为考虑到大小堆问题,所以使用了仿函数,这样只需多给定一个参数即可控制是大堆还是小堆。

下面给出完整代码:

#pragma once

#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;


template <class T>
class Less
{
public:
    bool operator()(const T& l, const T& r)
    {
        return l < r;
    }
};

template <class T>
class Greader
{
public:
    bool operator()(const T& l, const T& r)
    {
        return l > r;
    }
};

template <class T,class Compare = Greader<T>>
class Heap
{
public:
    Heap()
    {}

    Heap(const T a[], size_t n)
    {
        _heap.resize(n);
        for (size_t i = 0; i < n; ++i)
        {
            _heap[i] = a[i];
        }

        for (int root = (_heap.size()-2) >> 1; root >= 0; --root)
        {
            AdJustDown(root);
        }
    }

    void Push(const T& value)
    {
        _heap.push_back(value);

        if(_heap.size() > 1)
        AdJustUp();
    }

    void Pop()
    {
        assert(_heap.size() > 0);
        swap(_heap[0], _heap[_heap.size() - 1]);
        _heap.pop_back();
        if (_heap.size() > 0)//防止堆中只有一个节点,删除后为0
        AdJustDown(0);

    }

    const T& Top()//定义为const,防止堆顶被改破坏结构
    {
        return _heap[0];
    }

    size_t Size()
    {
        return _heap.size();
    }

    bool Empty()
    {
        return _heap.empty();
    }
private:
    void AdJustDown(int root)
    {
        int parent = root;
        int child = root * 2 + 1;
        while (child < _heap.size())
        {
            if ((child + 1) < _heap.size() && Compare()( _heap[child + 1] , _heap[child]))
                ++child;

            if (Compare()(_heap[child],_heap[parent]))
            {
                swap(_heap[parent] , _heap[child]);
                parent = child;
                child = child * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }

    void AdJustUp()
    {
        int child = _heap.size() - 1;
        int parent = (child - 1) >> 1;

        while (parent >= 0)//chile > 0
        { 
            if (Compare()(_heap[child] , _heap[parent]))
            {
                swap(_heap[child], _heap[parent]);
                child = parent;
                parent = (child - 1) >> 1;
            }
            else
            {
                break;
            }
        }
    }
private:
    vector<T> _heap;
};


优先级队列

在C++的标准库中,提供了优先级队列这个容器,其实底层就是一个堆的结构,只不过将堆封装了一层而已。其实名字叫个优先级队列,但总觉得和队列是不沾边的。
priority_queue 是容器适配器,它提供常数时间的(默认)最大元素查找,对数代价的插入与释出。
用 priority_queue 工作类似管理某些随机访问容器中的堆,好处是不可能突然把堆非法化。
下面给出代码:

#pragma once
#include"Heap.h"

template<class T,class Compare=Greader<T>>
class Priority_Queue
{
public:
    Priority_Queue()
    {}

    ~Priority_Queue()
    {}

    const T& Top()const
    {
        return hp.Top();
    }

    bool Empty()
    {
        return hp.Empty();
    }

    size_t Size()
    {
        return hp.Size();
    }
    void Pop()
    {
        hp.Pop();//堆中已经对元素的个数进行了判断
    }

    void Push(const T& data)
    {
        hp.Push(data);
    }

    void Print_Queue()
    {
        while (!hp.Empty())
        {
            cout << hp.Top() << " ";
            hp.Pop();  
        }
        cout << endl;
    }
private:
    Heap<T,Compare> hp;
};