STL中的优先级队列(priority_queue)的自己实现priqueue

这篇文章主要介绍堆（最大堆和最小堆），以及一些系统对一些任务，比如线程，进程做调度的时候，所采用的优先级队列。

主要思想就是，做一个最大堆（任务的权重最大的在顶端），把顶端的任务取出，重新做一个堆，处理该任务。

 

// 优先级队列.cpp : 定义控制台应用程序的入口点。

//



#include "stdafx.h"

#include <functional>

#include <iostream>

using namespace std;



template<typename T , class FuncCmp = std::less<T> >

class priqueue

{

	T * x;

	int n;

	int maxsize;

	FuncCmp comp;

private:

	inline void swap(T & l , T & r)

	{

		T tmp = l;

		l = r;

		r = tmp;

	}



public:

	void shiftup(int end)//将满足comp的元素，从底部提到顶部

	{

		//pre :  [1,n-1]是堆

		//post : [1,n]是堆

		int i = end;

		int p = i/2;

		while( i != 1 && comp(x[i],x[p]) )

		{

			swap(x[i],x[p]);

			i = p;

			p = i / 2;

		}

	}

	void shiftdown(int end)//将不满足comp的元素，从顶部往下移

	{

		//pre :  [2,n]是堆

		//post : [1,n]是堆

		int i = 1;

		int child;

		while (1)

		{

			child = 2*i;

			if (child > end)break;

			if(child == end)

			{

				if ( !comp(x[i],x[child]) )

				{

					swap(x[i] , x[child]);

				}

				break;

			}

			if (child < end)

			{

				if ( !comp(x[child],x[child+1]) )

				{

					++child;

				}

				if ( !comp(x[i],x[child]) )

				{

					swap(x[i],x[child]);

				}

				else

				{

					break;

				}

			}

			i = child;

		}

	}

	void push_queue(T t)

	{

		if (n == maxsize)return;



		x[++n] = t;

		shiftup(n);

	}

	T pop_queue()

	{

		if(n == 0)return T();

		T ret = x[1];

		x[1] = x[n--];

		shiftdown(n);

		x[n+1] = ret;

		return ret;

	}

	void make_heap()

	{

		if(n == 0 || n==1)return;

		for (int i = 2;i<=n ; ++i)

		{

			shiftup(i);

		}

	}

	priqueue(int m)

	{

		maxsize = m;

		n = 0;

		x = new T[maxsize + 1];

	}

	~priqueue()

	{

		if (x)

		{

			delete x;

			x = NULL;

		}

	}

	int size()const

	{

		return n;

	}

};



struct Tasks

{

	int priority;



	struct OtherData

	{

		int data1;

		int data2;

		int data3;

		int data4;

	};

};



inline bool CompareTasks(Tasks * t1 , Tasks * t2)

{

	return t1->priority < t2->priority;

}



struct CompareTasksType

{

public:

	bool operator()(Tasks * t1 , Tasks * t2)

	{

		return CompareTasks(t1,t2);

	}

};



int _tmain(int argc, _TCHAR* argv[])

{

	priqueue<Tasks * , CompareTasksType> q(12);



	Tasks t1; t1.priority = 12;

	Tasks t2; t2.priority = 20;

	Tasks t3; t3.priority = 15;

	Tasks t4; t4.priority = 29;

	Tasks t5; t5.priority = 23;

	Tasks t6; t6.priority = 17;

	Tasks t7; t7.priority = 22;

	Tasks t8; t8.priority = 35;

	Tasks t9; t9.priority = 40;

	Tasks t10; t10.priority = 26;

	Tasks t11; t11.priority = 51;

	Tasks t12; t12.priority = 19;



	q.push_queue(&t1);

	q.push_queue(&t2);

	q.push_queue(&t3);

	q.push_queue(&t4);

	q.push_queue(&t5);

	q.push_queue(&t6);

	q.push_queue(&t7);

	q.push_queue(&t8);

	q.push_queue(&t9);

	q.push_queue(&t10);

	q.push_queue(&t11);

	q.push_queue(&t12);



	//q.push_queue(12);

	//q.push_queue(20);

	//q.push_queue(15);

	//q.push_queue(29);

	//q.push_queue(23);

	//q.push_queue(17);

	//q.push_queue(22);

	//q.push_queue(35);

	//q.push_queue(40);

	//q.push_queue(26);

	//q.push_queue(51);

	//q.push_queue(19);



	while(q.size() != 0)

	{

		Tasks * pT = q.pop_queue();

		//do this task

		//...

		cout<<(pT->priority)<<endl;

	}



	return 0;

}