图的prim 斐波那契堆实现

#ifndef __BASE_H__
#define __BASE_H__
#include <iostream>
#include "binomial heap.h"
#include "fibonacci_heap.h"
using namespace std;
/*********************************stack**********************************/
template<class node>
class stack
{
public:
	stack(int n);
	~stack();
private:
	node *_s;
	int _size;
	int _height;
public:
	int height(){return _height;}
	void empty(){_height = 0;}
	bool push(const node& nd);
	bool pop(node& nd);
	void top(node& nd){nd = _s[_height-1];}
};
template <class node>
stack<node>::stack(int n)
{
	_s = new node[n];
	_size = n;
	_height = 0;
}

template <class node>
stack<node>::~stack()
{
	delete _s;
}

template <class node>
bool stack<node>::push(const node& nd)
{
	if (_height >= _size)return false;
	_s[_height++] = nd;
	return true;
}

template <class node>
bool stack<node>::pop(node& nd)
{
	if (_height <= 0)return false;
	nd = _s[--_height];
	return true;
}

/**********************************queue*********************************/
template<class node>
class queue
{
public:
	queue(int n);
	~queue();
private:
	node *_q;
	int _size;
	int _head;
	int _tail;
public:
	bool inqueue(const node &nd);
	bool dequeue(node &nd);
	int length(){return (_tail - _head + _size)%_size;}
	void empty(){_head = _tail = 0;}
};

template<class node>
queue<node>::queue(int n)
{
	_q = new node[n+1];
	_size = n+1;
	_head = _tail = 0;
}

template<class node>
queue<node>::~queue()
{
	if (_q)
	{
		delete _q;
	}
}


template<class node>
bool queue<node>::inqueue(const node &nd)
{
	if ((_tail+1)%_size== _head)return false;
	else
	{
		_q[_tail] = nd;
		_tail = (_tail+1)%_size;
		return true;
	}
}

template<class node>
bool queue<node>::dequeue(node &nd)
{
	if (_tail == _head)return false;
	else
	{
		nd = _q[_head];
		_head = (_head + 1)%_size;
		return true;
	}
}
/*********************************graph*************************************/
template <class vertex , class edge>
class graph
{
protected:
	int _vcnt , _ecnt;
	int _capacity;
	int *_prt;
	int *_dep;
	int *_vist;

public:
	graph(){_capacity = _vcnt = _ecnt = 0;_prt = _dep = _vist = NULL;}
	virtual bool insert_vertex(vertex ver) = 0;
	virtual bool insert_edge(int v1 , int v2 , edge ed) = 0;
	virtual bool BFS(int s) = 0 ;
	virtual bool DFS(int s) = 0 ;
	virtual bool DFS_stack(int s) = 0 ;
	virtual bool visit_result() = 0;
	int num_vertex(){return _vcnt;}
	int num_edge(){return _ecnt;}
};
/*******************************mtxgraph*************************************/
template <class vertex , class edge>
class mtxgraph : public graph<vertex , edge>
{
private:
	vertex *_ver;
	edge **_ed;
public:
	mtxgraph();
	mtxgraph(int n);
	mtxgraph(mtxgraph& mg);
	~mtxgraph();
	virtual bool insert_vertex(vertex ver);
	virtual bool insert_edge(int v1 , int v2 , edge ed);
	virtual bool BFS(int s);
	virtual bool DFS(int s);
	virtual bool DFS_stack(int s);
	virtual bool visit_result();
private:
	void DFSrecur(int s , int *color , int time , int pare);
};

template <class vertex , class edge>
mtxgraph<vertex , edge>::mt