多服务台排队系统的模拟

#include 
#include 
#include 
using namespace std;

//队列的链式结构
template
class linkQueue
{
private:
    struct node
    {
        T data;
        node*next;
        node（const T&xnode*N=NULL）{data=x;next=N;}
        node（）:next（NULL）{}
        ~node（）{}
    };
    node*f;
public:
    linkQueue（）{ f=NULL; }
    ~linkQueue（）
    {
        node*t;
        while（f!=NULL）
        { t=f; f=f->next; delete t; }
    }

    bool isEmpty（）{ return f==NULL; }

    void enQueue（T &x）//插入
    {
        if（ f==NULL ） f=new node（x）;
        else{
            node*r=f;
            while（r->next!=NULL） r=r->next;
            r->next=new node（x）;
        }
    }

    T deQueue（）//删除
    {
        node*t=f; T value=f->data;
        f=f->next;
        delete t;
        return value;
    }

    T getHead（）//取队首元素
    { T value=f->data; return value; }
};

//优先级队列定义
template 
class priorityQueue
{
public:

    //构造函数-空
    priorityQueue（int capacity=100）
        {
            array=new T[capacity];
            maxSize=capacity;
            currentSize=0;
        }

    priorityQueue（T data[]int size）;
    ~priorityQueue（） { delete []array; }

    bool isEmpty（） { return currentSize==0; }
    void enQueue（T &x）;
    T deQueue（）;
    T getHead（） { return array[1]; }

    int findMin（T x）;
    void decreaseKey（int i T value）;

    void show（）
    {
        cout<        for（int j=1; j<=currentSize; ++j）
            cout<        cout<    }

private:
    int currentSize;
    T *array;
    int maxSize;

    void doubleSpace（）;
    void buildHead（）;
    void percolateDown（int hole）;
};

//插入
template 
void priorityQueue::enQueue（T & x）
{
    if（currentSize==maxSize-1） doubleSpace（）;
    // 向上过滤
    int hole=++currentSize;

    //在x大于空结点的父结点或已过滤到根时终止循环
    for（; hole>1 && x   		array[hole]=array[hole/2];
    array[hole]=x;
}

//删除
template 
T priorityQueue::deQueue（）
{
    T minItem;
    minItem = array[1];
    array[1] = array[currentSize--]; //将最后一个元素挪到根节点
    percolateDown（1）; //向下过滤
    return minItem;
}

template 
void priorityQueue::percolateDown（int hole）
{
    int child;
    T tmp=array[hole];
    for（; hole*2<=currentSize; hole=child） //每次循环下移一层
    {
        child=hole*2; //指向左儿子
        if（child!=currentSize && array[child+1]        child++; //如果右儿子存在且小于左儿子，指向右儿子
        if（array[child]        else break;
      }
    array[hole]=tmp;
}

//堆构造
template 
void priorityQueue::buildHead（）
{
    for（int i=currentSize/2; i>0; --i）
        percolateDown（i）;//调用向下过滤
}

//构造函数-已存在某个数组
template 
priorityQueue::priorityQueue（T *itemint size）
    :maxSize（size+10）currentSize（size）
{