【数据结构】优先级队列的实现(适配器模式)

原创 2016年05月30日 17:18:52

代码按照适配器模式实现,若理解了堆的内部怎么实现的,那优先级的队列实现则是非常简单的了,堆的设计大家不明白的话,可以查看我的博客http://10740184.blog.51cto.com/10730184/1767076


建立PriorityQueue.hpp:

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


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

template<class T>
struct Greater
{
    bool operator() (const T& l, const T& r)
    {
        return l>r;
    }
};


template<class T,template<class> class Compare=Less>
class Heap
{
public:
    Heap()
        :_a(NULL)
    {}


    Heap(const T* a,size_t size)
    {
        for (int i = 0; i < size; i++)
        {
            _a.push_back(a[i]);
        }
        for (int i = (size - 2) / 2; i >= 0; i--)
        {
            _adjustDown(i);
        }
    }


    void _adjustDown(size_t parent)
    {
        Compare<T> com;
        size_t child = 2 * parent + 1;
        size_t size = _a.size();
        while (child<size)
        {
            if (child + 1<size && com(_a[child + 1],_a[child]))
            {
                ++child;
            }
            if (com(_a[child],_a[parent]))
            {
                swap(_a[child], _a[parent]);
                parent = child;
                child = 2 * parent + 1;
            }
            else
            {
                break;
            }
        }
    }


    void Push(const T& x)
    {
        _a.push_back(x);
        _adjustUp(_a.size()-1);
    }


    void _adjustUp(size_t child)
    {
        int parent = (child - 1) / 2;
        Compare<T> com;
        while (child>0)
        {
            if (com(_a[child],_a[parent]))
            {
                swap(_a[parent], _a[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }


    size_t Size()
    {
        size_t size = _a.size();
        return size;
    }


    bool Empty()
    {
        assert(Size() >= 0);
        return Size() == 0;
    }


    void Pop()
    {
        assert(_a.Size() > 0);
        swap(_a[0], _a[Size - 1]);
        _a.pop_back();
        _adjustDown(0);        
    }


    T& GetTop()
    {
        return _a[0];
    }


    void Print()
    {
        cout << "大堆序列:" << endl;
        for (int i = 0; i < _a.size(); i++)
        {
            cout << _a[i] << "  ";
        }
        cout << endl;
    }
public:
    vector<T> _a;
};


template<class T, template<class> class Compare = Less>
class PriorityQueue
{
public:
    void Push(const T& x)
    {
        _hp.Push(x);
    }


    void Pop()
    {
        _hp.Pop();
    }


    size_t Size()
    {
        return _hp.Size();
    }


    bool Empty()
    {
        _hp.Empty();
    }


    T& Top()
    {
        return _hp.GetTop();
    }


    void Print()
    {
        _hp.Print();
    }
private:
    Heap<T,Compare> _hp;
};


建立PriorityQueue.cpp文件:

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include "PriorityQueue.hpp"

void Test()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    PriorityQueue<int,Greater> pq;
    pq.Push(10);
    pq.Push(11);
    pq.Push(13);
    pq.Push(12);
    pq.Push(16);
    pq.Push(18);
    pq.Push(15);
    pq.Push(17);
    pq.Push(14);
    pq.Push(19);

    pq.Print();
}


int main()
{
    Test();
    system("pause");
    return 0;
}


本文出自 “Han Jing's Blog” 博客,请务必保留此出处http://10740184.blog.51cto.com/10730184/1768025

数据结构之带优先级的队列(C语言实现)

数据结构之带优先级的队列(C语言实现)
  • kang___xi
  • kang___xi
  • 2016年12月01日 21:48
  • 1195

优先级队列是一种什么样的数据结构

优先级队列(PriprityQueue)是一种无界队列,基于优先级堆,它的元素根据自然顺序或者通过实现Comparator接口的自定义排序方式进行排序。这篇文章,我们将创建一个Items的优先级队列,...
  • chuntiandejiaobu10
  • chuntiandejiaobu10
  • 2016年09月07日 20:52
  • 769

数据结构-堆实现优先队列(java)

队列的特点是先进先出。通常都把队列比喻成排队买东西,大家都很守秩序,先排队的人就先买东西。但是优先队列有所不同,它不遵循先进先出的规则,而是根据队列中元素的优先权,优先权最大的先被取出。这就很像堆的特...
  • tuke_tuke
  • tuke_tuke
  • 2015年12月19日 15:56
  • 2788

【适配器模式】实现优先级队列

【适配器模式】由于建立大堆和建立小堆方式相同,代码相似,所以可以通过添加一个比较器(利用Compare,定义伪函数Less和Greater)实现大小数据的比较,防止大量代码重复。template st...
  • Scenlyf
  • Scenlyf
  • 2016年06月11日 18:53
  • 173

数据结构--优先级队列

优先级队列:优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。(优先权可根据具体形势具体定义) 优先级对列是堆的应用之一, 它的具体实现以堆为原型。 仿函数:...
  • qq1010234991
  • qq1010234991
  • 2016年04月27日 11:24
  • 264

C++数据结构 之 优先队列_Priority Queue

C++数据结构 之 优先队列_Priority Queue源代码只包含头文件注:需要C++11的支持。...
  • liu798675179
  • liu798675179
  • 2016年08月10日 11:53
  • 785

【STL学习】优先级队列Priority Queue详解与C++编程实现

优先级队列Priority Queue介绍 优先级队列是一个拥有权值观念的queue。它允许在底端添加元素、在顶端去除元素、删除元素。 优先级队列内部的元素并不是按照添加的顺序排列,而是自...
  • xiajun07061225
  • xiajun07061225
  • 2013年01月30日 16:43
  • 14131

数据结构: 优先队列的应用

这里介绍一种重要的略为复杂的数据结构“优先队列”.我所提供的不是教学,而是希望提供一个解决类似问题的思路.因此以学习为目的,而不是以实用, 而且涉及到较多的名词概念或术语,对于不懂的建议查找数据结构的...
  • ZhangYv
  • ZhangYv
  • 2003年08月15日 17:06
  • 7061

用堆实现优先级队列 Java实现

优先级队列分为最大优先级队列和最小优先级队列。本文介绍基于大根堆实现最大优先级队列。关于堆的介绍见另一篇博文: 堆这种数据结构 Java实现 最小优先级队列的实现可以在本文最后给出的githu...
  • l294265421
  • l294265421
  • 2016年03月19日 00:14
  • 1593

JavaScript数据结构之队列

队列和栈非常的类似,但是使用了不同的原则,栈是先进后出,而队列是先进先出,即遵循的是FIFO(First In First Out,先来先服务)。队列也可以这样形象地想象成是将数组装到一根管子里,一边...
  • L_in12
  • L_in12
  • 2016年06月27日 11:10
  • 644
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【数据结构】优先级队列的实现(适配器模式)
举报原因:
原因补充:

(最多只允许输入30个字)