用C++的类做三种优先队列的实现

学过数据结构的都知道优先队列这种东西，普通的队列是依据入队顺序，先入队的先出队，而优先队列则是依照键值，键值越大（或越小），就越先出队。

所以，优先队列基本支持push，pop，empty，size，top，这几种操作。最近在看C++prime，学了类之后觉得非常适合用来实现高级数据结构，于是就动手做了一下，花了一周，终于弄好了。以下的实现都默认最小堆。

二叉堆：

最常用，最简单的堆实现，因为二叉堆是完全二叉树，所有可以使用顺序存储结构，也就是说，数组来保存数据。二叉堆主要基于上滤与下滤操作来维持堆序（任意节点大与等于或小于等于他的子节点）而完全二叉树基本是平衡树，所以这些操作都是log2 N的时间复杂度，最后顺便一提，二叉堆可用于实现堆排序的算法。

#include <iostream>
#include <vector>

class Bheap{//默认最小堆
public:
    typedef int Element;
    Bheap(const Element &Most);
    Bheap(Element *arr, int size, const Element &Most);
    ~Bheap();
    void push(const Element &e);
    void pop();
    bool empty();
    const Element& top();
    int size();
    void sort();
private:
    std::vector<Element> data;
    Element MostEle;
    void PercolateDown(int loca);
    void PercolateUp(int loca);
};

void Bheap::PercolateDown(int loca){
    int j, cur = data[loca];
    for (j = loca; j*2<data.size();){
        j *=2;
        if (j + 1 < data.size() && data[j + 1] < data[j]){
            j++;
        }
        if (data[j]<cur)
            data[j / 2] = data[j];
        else{
            j /= 2;
            break;
        }
    }
    data[j] = cur;
}
void Bheap::PercolateUp(int loca){
    int e = data[loca];
    while (1){
        if (e<data[loca /2]){
            data[loca] = data[loca / 2];
            loca /=2;
        }
        else{
            break;
        }
    }
    data[loca] = e;
}
Bheap::~Bheap()
{
}
Bheap::Bheap(Element *arr, int size, const Element &Most) :data(1, Most), MostEle(Most){
    for (int i = 0; i < size; i++){
        data.push_back(arr[i]);
    }
    for (int i = ((this->size()) /2); i > 0; i--){
        PercolateDown(i);
    }
}
Bheap::Bheap(const Element& Most) : data(1, Most), MostEle(Most)
{
}
void Bheap::push(const Element &e){
    data.push_back(e);
    PercolateUp(data.size() - 1);
}
void Bheap::pop(){
    data[1] = data[data.size() - 1];
    data.resize(data.size() - 1);
    PercolateDown(1);
}
bool Bheap::empty(){
    return data.size() <= 1;
}
const Bheap::Element& Bheap::top(){
    return data[1];
}
int Bheap::size(){
    return data.size() - 1;
}
void Bheap::sort(){
    for (int i = data.size() - 1; i > 0; i--){
        Element t = data[1];
        data[1] = data[i];
        data[i] = t;
        int j, cur = data[1];
        for (j = 1; j * 2<i;){
            j *=2;
            if (j + 1 < i && data[j + 1] < data[j]){
                j++;
            }
            if (data[j]<cur)
                data[j / 2] = data[j];
            else{
                j /= 2;
                break;
            }
        }
        data[j] = cur;
    }
}

左式堆：

左式堆是一颗二叉树，一般来说，我们更都喜欢平衡的树，平衡的树深度小，各种操作起来效率都更高，但是，左式堆却反其道而行之，最求不平衡的树，在实现avl树时，我们使用了左右子树的深度来作为树是否“比较平衡”的指标，而在左式堆中，我们也有类似的指标，npl（NULL path length），规定子节点数为0与1的节点的npl为0，空节点的npl为-1，任意节点的npl为他所有子节点中npl小的节点的npl+1。左式堆就是保持任意节点的左子树npl始终大于等于右子树的npl，这样的效果就是左子树始终比右子树深，虽然左子树深了，但是右子树就浅了啊，于是就可以大概保证push，pop操作为log2N，而且，不同于二叉堆，左式堆可以高效地支持合并操作，时间复杂度也是log2N左右，甚至，左式堆的所有操作都是基于合并操作。那么具体是怎么合并呢？因为是堆，于是保持着堆序，对于两个左式堆，我们比较根处的值，将小的堆的右子树与大的堆合并，并作为小的堆新的右子树，并且要更新npl，并根据npl决定是否交换子树，上面说过，左子树深了，右子树就浅了，于是就不用担心递归实现会爆栈来，因为，右子树非常浅（不大于log2N），深到递归实现会爆栈所需的数据是夸张的，所有可以放心地递归实现，但是我用了堆栈做了非递归实现（说了那么多，你居然没有用递归）。

#include <iostream>
#include <vector>
#include <stack>

class Lheap
{
private:
    typedef int Element;
    struct LheapNode
    {
        Element e;
        LheapNode*left;
        LheapNode*right;
        int npl;
        LheapNode();
        ~LheapNode();
        void swapchild();
        void renewnpl();
        const LheapNode& operator = (const LheapNode&a);
    };
    LheapNode *node;
    int Size;
    void Merge1(Lheap &a);
public:
    Lheap();
    Lheap(const Element &E);
    Lheap(const LheapNode* a);
    Lheap(const Element *arr, int size);
    ~Lheap();
    void Merge(const Lheap &a);
    void pop();
    const Element &top();
    bool empty();
    int size()const;
    void push(const Element &E);
};

Lheap::LheapNode::LheapNode() :left(NULL), right(NULL), npl(0){}
Lheap::LheapNode::~LheapNode(){
    delete left;
    delete right;
}
void Lheap::LheapNode::renewnpl(){
    if (right){
        if (left){
            if (right->npl > left->npl){
                swapchild();
            }
            npl = right->npl + 1;
        }
        else{
            swapchild();
            npl = 0;
        }
    }
    else{
        npl = 0;
    }
}
void Lheap::LheapNode::swapchild(){
    LheapNode* t = left;
    left = right;
    right = t;
}
const Lheap::LheapNode& Lheap::LheapNode:: operator = (const LheapNode&a){
    if (a.left){
        if (left == NULL)
            left = new LheapNode;
        *left = *a.left;
    }
    if (a.right){
        if (right == NULL)
            right = new LheapNode;
        *right = *a.right;
    }
    npl = a.npl;
    e = a.e;
    return *this;
}

Lheap::Lheap() :node(NULL),Size(0)
{
}
Lheap::Lheap(const Element *arr, int size) : node(NULL), Size(0)
{
    node = new LheapNode;
    node->e = arr[0];
    for (int i = 1; i < size; i++)
        push(arr[i]);
}
Lheap::Lheap(const Element &E) : node(NULL), Size(0){
    node = new LheapNode;
    node->e = E;
}
Lheap::~Lheap()
{
    delete node;
}
bool Lheap::empty(){
    return node == NULL;
}
void Lheap::Merge1(Lheap &a){
    if (node == NULL){
        node = a.node;
        a.node = NULL;
        return;
    }
    std::stack<LheapNode*> s;
    s.push(node);
    LheapNode *b = a.node,*t;
    while (1){
        if (s.top()->e < b->e){
            if (s.top()->right){
                s.push(s.top()->right);
            }
            else{
                break;
            }
        }
        else{
            if (b->right){
                t = s.top();s.pop();
                s.push(b);
                b = t;
                s.push(s.top()->right);
            }
            else{
                t = s.top();s.pop();
                s.push(b);
                b = t;
                break;
            }
        }
    }
    while (!s.empty()){
        t = s.top(); s.pop();
        t->right = b;
        b = t;
        b->renewnpl();
    }
    node = b;
    a.node = NULL;
}
void Lheap::Merge(const Lheap &a){
    Lheap t;
    t.node = new LheapNode;
    *t.node = *a.node;//此处可根据需要选择是否要保留被并入的堆，不需要的话直接Merge1（a)就好了
    Merge1(t);
    Size += a.Size;
}
void Lheap::push(const Element &E){
    Lheap t(E);
    Merge1(t);
    Size++;
}
void Lheap::pop(){
    LheapNode *L = node->left,*R=node->right;
    node->left = node->right =NULL;
    delete node;
    node = L;
    if (R){
        Lheap t;
        t.node = R;
        Merge1(t);
    }
    Size--;
}
const Lheap::Element& Lheap::top(){
    return node->e;
}
int Lheap::size()const{
    return Size;
}

二项队列：

二项树，是一种特殊的树，他的特点是，我们把一棵有2^k个节点的树叫做K树，k树有k-1个子树，分别是0到k-1树，而二项队列就是按k树k值大小排列的队列（说好的队列呢），此外，二项队列有一个最大的特点，那就是每种树都只能存在一棵，如果存在两颗呢？那我们就要将他们合并为一棵树，比如说，如果有两颗0树，那么，我们就要将他们合并为一棵1树，怎么合并呢？想想，我们要构造的是堆，于是二项树就必须符合堆序，那我们就只要将根值大的作为小的的子树。说到这些，有没有觉得熟悉呢？我们看一下二进制的加法，

1001  8+0+0+1

0011  0+0+2+1

1100  8+4+0+0

明白了吧，二项队列的具体结构与插入的值无关，虽然他是个堆，但是他长得怎么样，和你给他什么值没什么关系，很奇怪对不对，但真的是这样，二项队列的结构取决于插入元素的个数。二项队列的特质，使他唯一对应于一个二进制数字，于是我们可以利用两个堆大小对应二进制数字的加法来控制流程。然后，我们对它的操作做分析，首先对合并操作进行分析，首先，我们知道，对于一个有N个元素的二项队列，长度不超过Log2N，因为，一个二项队列对应一个二进制整数。合并相当于一次加法运算，二项队列的合并就是对其队列中的二项树自小到大进行合并，插入下一位的操作（进位），那么复杂度是O（log2N），pop操作则是在队列中寻找根最小的二项树（花费Log2N），将其子树当成新队列，与除去了二项队列中该树，再将该队列与新队列合并，操作也是log2N，最后，就是push操作，二项队列最大的特点就是，虽然不能保证每次操作都是o（1）的时间复杂度，但是可以保证M次push操作，平均的时间复杂度是（MLog2N),为什么呢？我们来分析一下，对于push操作，相当于一个二项队列与对应1的二项队列相加。首先，先明白这样一件事，push操作花费的时间取决于二项队列结尾出现第一个0之前1的个数，比如说，00就只需要一次插入，01就需要一次插入，一次合并，011就需要一次插入，两次合并，假设一个二项队列在进行push操作前大小是k，通过M次插入操作变为k+M，该过程中，最低位为1的概率有1/2，于是有一半的数需要一次合并，而显然剩下的树不需要再合并，然后在这一半的数中，又有一半的数第二位为1，他们需要第二次合并，而另一半则不需要，依此类推，从k到k+M-1这M个数，所需合并次数为 M/2+M/4+M/8....+1，假设M为偶数（因为奇数结果也差不了多少），则为M（1+1/2+1/4+。。。+1/Log2M)=M-1,于是M次合并，平均需要O（M-1/M）=O（1）的时间复杂度。这种分析方式就是所谓的摊还分析了，有的数据结构，比如伸展树，比如斜堆，都有虽然不能保证每次操作是O（x），但是能保证M次操作为O（Mx）的特点，这种分析比较复杂，我到现在都不是很会，于是你会发现我在分析上面两种实现时草草带过，二叉堆是因为真的没有什么好说的，左式堆是因为我真的没有什么会说的。。。还是好好学习一下怎么进行摊还分析吧。另外，优先队列的实现中没有斜堆，因为他和左式堆差不多，区别就像AVL树与伸展树差不多，他不会通过npl这种东西来判断是否交换子树，他只是简单粗暴地交换每个合并的节点的子树。。。。最后吐槽一下，说好的队列，结果我使用deque来作为队列，但最后才发现，直接开个32大小的数组反而比较实在，毕竟可以存2^31大约10亿个数据了，对于我这种没见过世面的人来说已经妥妥的了。

#include <iostream>
#include <vector>
const int Default_size=32;
class Bqueue
{
private:
    typedef int Element;
    struct BtreeNode
    {
        BtreeNode*child;
        BtreeNode*sibling;
        Element data;
        BtreeNode();
        ~BtreeNode();
    };
    typedef BtreeNode * Btree;
    std::vector<Btree> q;
    int Size;
public:
    Bqueue();
    Bqueue(int size);
    Bqueue(Element *arr, int size);
    ~Bqueue();
    void push(const  Element &e);
    void pop();
    Bqueue& Merge(Bqueue &Q);
    int size()const;
    const  Element& top()const;
    bool empty()const;
    Btree combineTree(Btree T1, Btree T2)const;
};

Bqueue::BtreeNode::BtreeNode():child(NULL), sibling(NULL){}
Bqueue::BtreeNode::~BtreeNode(){
    delete child;
    delete sibling;
}

Bqueue::Bqueue() :Size(0){
    q.resize(Default_size);
}
Bqueue::Bqueue(int size) : Size(size){
    q.resize(Default_size);
}
Bqueue::~Bqueue(){
    for (std::vector<Btree>::iterator p = q.begin(); p != q.end(); p++)
        delete *p;
}
Bqueue& Bqueue::Merge(Bqueue &Q){
    Btree T1, T2,Carry=NULL;
    Size += Q.size();
    for (int i = 0, j = 1;j<=Size; i++, j *= 2){
        T1 = q[i]; T2 = Q.q[i];
        switch (!!T1+2*!!T2+4*!!Carry)
        {
        case 0:
        case 1:
            break;
        case 2:
            q[i] = T2;
            Q.q[i] = NULL;
            break;
        case 3:
            Carry = combineTree(T1, T2);
            q[i] = Q.q[i] = NULL;
            break;
        case 4:
            q[i] = Carry;
            Carry = NULL;
            break;
        case 5:
            Carry = combineTree(T1, Carry);
            q[i] = NULL;
            break;
        case 6:
            Carry = combineTree(Carry, T2);
            Q.q[i] = NULL;
            break;
        case 7:
            q[i] = Carry;
            Carry = combineTree(T1, T2);
            Q.q[i] = NULL;
            break;
        default:
            break;
        }
    }
    return *this;
}
int Bqueue::size()const{
    return Size;
}
void Bqueue::push(const Element &e){
    Btree T = new BtreeNode,T1;
    T->data = e;
    Size += 1;
    for (int i = 0,j=1; j <= Size&&T; i++,j*=2){
        T1 = q[i];
        switch (!!T*2+!!T1){
        case 2:
            q[i] = T;
            T = NULL;
                break;
        case 3:
            q[i] = NULL;
            T=combineTree(T, T1);
                break;
        default:
            break;
        }
    }
}
void Bqueue::pop(){
        int i, j, Mintree=0;
        Btree DeletedTree, Oldroot;
        while (q[Mintree]==NULL)
        {
            Mintree++;
        }
        for (i = Mintree+1, j = 1<<i; j <= Size; j *= 2,i++)
            if (q[i])
            Mintree = q[Mintree]->data<q[i]->data?Mintree:i;
        Oldroot = DeletedTree = q[Mintree];
        DeletedTree = DeletedTree->child;
        Oldroot->child = NULL;
        delete Oldroot;
        Bqueue DeleteQueue((1 << Mintree) - 1);
        for (i = Mintree - 1; i >= 0; i--){
            DeleteQueue.q[i] = DeletedTree;
            DeletedTree = DeletedTree->sibling;
            DeleteQueue.q[i]->sibling = NULL;
        }
        q[Mintree] = NULL;
        Size -= DeleteQueue.size() + 1;
        Merge(DeleteQueue);
}
bool Bqueue::empty()const{
    return Size == 0;
}
const Bqueue:: Element& Bqueue::top()const{
    int res=0;
    while (q[res] == NULL)
    {
        res++;
    }
    for (int i = res + 1, j = 1 << i; j <= Size; j *= 2, i++)
        if (q[i])
            res = q[res]->data<q[i]->data ? res : i;
    return q[res]->data;
}
Bqueue::Btree Bqueue::combineTree(Btree T1,Btree T2)const{
        if (T1->data > T2->data)
            return  combineTree(T2, T1);
        T2->sibling = T1->child;
        T1->child = T2;
        return T1;
    }

最后，我们实际看一下各种实现的效果，我们用合并果子这道经典贪心算法来测试一下。

二叉堆：

  • 测试点1 Accepted / 1ms / 12396kB
  • 测试点2 Accepted / 2ms / 12396kB
  • 测试点3 Accepted / 2ms / 12396kB
  • 测试点4 Accepted / 19ms / 12396kB
  • 测试点5 Accepted / 18ms / 12396kB
  • 测试点6 Accepted / 51ms / 12396kB
  • 测试点7 Accepted / 50ms / 12396kB
  • 测试点8 Accepted / 45ms / 12396kB
  • 测试点9 Accepted / 53ms / 12396kB
  • 测试点10 Accepted / 50ms / 12396kB

STL 的优先队列《vector》

　　

  • 测试点1 Accepted / 5ms / 12400kB
  • 测试点2 Accepted / 8ms / 12400kB
  • 测试点3 Accepted / 14ms / 12400kB
  • 测试点4 Accepted / 36ms / 12400kB
  • 测试点5 Accepted / 45ms / 12400kB
  • 测试点6 Accepted / 85ms / 12400kB
  • 测试点7 Accepted / 84ms / 12400kB
  • 测试点8 Accepted / 80ms / 12400kB
  • 测试点9 Accepted / 85ms / 12400kB
  • 测试点10 Accepted / 87ms / 12400kB

二项队列：

　　

  • 测试点1 Accepted / 3ms / 12396kB
  • 测试点2 Accepted / 17ms / 12396kB
  • 测试点3 Accepted / 20ms / 12396kB
  • 测试点4 Accepted / 77ms / 12396kB
  • 测试点5 Accepted / 101ms / 12528kB
  • 测试点6 Accepted / 202ms / 12660kB
  • 测试点7 Accepted / 196ms / 12660kB
  • 测试点8 Accepted / 195ms / 12660kB
  • 测试点9 Accepted / 211ms / 12660kB
  • 测试点10 Accepted / 190ms / 12660kB

左式堆：
　　

  • 测试点1 Accepted / 2ms / 12400kB
  • 测试点2 Accepted / 29ms / 12400kB
  • 测试点3 Accepted / 30ms / 12400kB
  • 测试点4 Accepted / 143ms / 12528kB
  • 测试点5 Accepted / 164ms / 12528kB
  • 测试点6 Accepted / 391ms / 12784kB
  • 测试点7 Accepted / 379ms / 12784kB
  • 测试点8 Accepted / 381ms / 12784kB
  • 测试点9 Accepted / 376ms / 12784kB
  • 测试点10 Accepted / 357ms / 12784kB

可以看出，简单除暴的二叉堆效率是最高的，左式堆最不给力。。。

时间： 2024-10-11 06:54:02

用C++的类做三种优先队列的实现的相关文章

20151015_系统分析阶段分析类的三种类型

在系统分析阶段将分析类分为三种类型:实体类.界面类.控制类. 1.实体类 实体类主要是作为数据管理和业务逻辑处理层面上存在的类别: 它们主要在分析阶段区分 实体类的主要职责是存储和管理系统内部的信息,它也可以有行为,甚至很复杂的行为,但这些行为必须与它所代表的实体对象密切相关 基本信息 上述给出的实体类的定义是比较抽象的.类具有继承和递归的特点,实体类可以在抽象类的基础上进一步定义具体的类 实体类是用于对必须存储的信息和相关行为建模的类.实体对象(实体类的实例)用于保存和更新一些现象的有关信息,

类的三种成员与继承

对于类而言,一共有三种成员类型,分别为private,protected,public.其中,如果数据成员的类型为private,可以默认不写.对于在类外使用的情况,private和protected是一致的,均不可以由外部直接访问,而public所包含的成员是可以由外部直接访问的.下面给出一个基本的例子. 12345678910111213141516171819202122 class Time { private: int hour; int minute; protected: int

C++ 中string类的三种模拟实现方式

1.原始版本(拷贝构造和赋值运算符重载时,需要重新开辟空间) #include <iostream> #include <string> using namespace std; class String { friend ostream& operator<<(ostream& os, const String& S); public: String(char* str = "") :_str(new char[strlen

持久化类的三种实例状态

一个持久化类的实例可能处于三种不同状态中的某一种.这三种状态的定义则与所谓的持久化上下文(persistence context)有关.hibernate的session对象就是这个所谓的持久化上下文. 瞬态:该实例从未与任何持久化上下文关联过.它没有持久化标识(相当于主键值). 持久化:实例目前与某个持久化上下文有关联.它拥有持久化标识(相当于主键值),并且可能在数据库中有一个对应的行.对于某一个特定的持久化上下文,hiberanate保证持久化标识与java标识(其值代表对象在内存中的位置)

02-Hibernate实体类的三种状态

一．Hibernate的实体类有三种状态 Transient:瞬时状态,不被hibernate session管理,而且实体数据在数据库不存在 Persistent:持久化状态,被session管理,此时的对象被放在session的缓存中,实体对象存在数据库中. Detached:离线状态,实体对象在数据库中有数据与之对应,但是不被session管理 注意:被session所管理的实体对象,当对象的属性发生改变,在提交事务的时候会自动更新改变后的属性到数据库中. 下图是hibernate试题对象

File类的三种构造方法

1 package cn.zmh.File; 2 3 import java.io.File; 4 /* 5 * 6 * File类的构造方法 三种重载形式 7 * 8 * */ 9 public class FileDemo1 { 10 public static void main(String[] args) { 11 fun2(); 12 } 13 //3 传递 父路径 子字符串路径 14 // 好处 父路径 File类型 父路径就可以直接调用File类的方法 ***** 15 publ

python类的三种方法

一.先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法. ps.python中self,cls的区别 普通实例方法,第一个参数需要是self,它表示一个具体的实例本身.如果用了staticmethod,那么就可以无视这个self,而将这个方法当成一个普通的函数使用.而对于classmethod,它的第一个参数不是self,是cls,它表示这个类本身. # coding:utf-8 class Foo(object): """类三种方法语法形式"&

Javascript定义类的三种方法分析

一.构造函数法 function User() { this.name = "张三"; } 生成实例的时候,使用new关键字. var user1 = new User(); alert(user1.name); // 张三 类的属性和方法,还可以定义在构造函数的prototype对象之上. User.prototype.sing = function(){ alert("only you!"); } 缺点:比较复杂,用到了this和prototype,不易编写和阅

3.Struts2中Action类的三种写法

一.普通的POJO类(没有继承没有实现) public class DemoAction1 { public String execute(){ System.out.println("DemoAction1是普通的POJO类..."); return null; } } <!-- 普通的POJO类 --> <action name="action1" class="com.struts2.web.action2.DemoAction1&