ADT队列实现

ADT队列

　　队列（queue）是一种特殊的有序表，其插入操作都在表的一端进行，删除操作都在表的另一端，所以队列先进先出（FIFO）表

队列基本操作：入列，出列，

队列实现：顺序队列，循环队列，链队列

1.顺序队列：用一维数组和两个变量front，rear。

template<class T> class Queue
{
    public:
        Queue():front(-1),rear(-1){}
        void push(T);
        void pop();
        T Front();
        bool isEmpty();
        bool isFull();
        void clear();
    private:
        T array[MAX_QUEUE_SIZE];
        int front,rear;
};

template<class T> bool Queue<T>::isEmpty()
{
    if (front==rear)
        return true;
    else
        return false;
}

template<class T> bool Queue<T>::isFull()
{
    if (rear>=MAX_QUEUE_SIZE-1)
        return true;
    else
        return false;

}

template<class T> void Queue<T>::push(T value)
{
    if (isFull())
    {
        cerr<<"queue full"<<endl;
    }
    else
    {
        array[++rear]=value;
    }


}

template<class T>void Queue<T>::pop()
{
    if (isEmpty())
    {
        cerr<<"queue empty"<<endl;
    }
    else
    {
        front++;
    }

}
template<class T> T Queue<T>::Front()
{
    if (isEmpty())
        return 0;
    else
    {
        return array[front+1];
    }
}

template<class T> void Queue<T>::clear()
{
    front=rear=-1;
}

2.循环队列

　　随着队列中数据插入删除，队列逐渐右移，队列的下标最终会位于max_stack_size-1，说明队列已满，需要将队列左移。如果把数组看成循环的，可以有效解决这一问题，此时，front,rear初始化为0不是1，下标front始终指向队首元素位置的前一个位置，下标rear指向队尾，队列为空当且仅当front==rear。如果队列容量是max_size,则队列满时，front==rear，这样就不能区分空和满，因此约定，max_queue_size队列最多容纳max_queue_size-1个元素，这样队列满时，（rear+1）%max_queue_size=front。

template<class T> class circular_Queue
{
    public:
        circular_Queue():front(0),rear(0){}
        bool isEmpty();
        bool isFull();
        void push(T);
        void pop();
        T Front();
        void clear();
    private:
        T array[MAX_QUEUE_SIZE];
        int front,rear;

};

template<class T> bool circular_Queue<T>::isEmpty()
{
    if (front==rear)
        return true;
    else
        return false;
}

template<class T>bool circular_Queue<T>::isFull()
{
    if ((rear+1)%MAX_QUEUE_SIZE==front)
        return true;
    else
        return false;
}

template<class T> void circular_Queue<T>::push(T value)
{
    if (isFull())
    {
        cerr<<"queue full"<<endl;
    }
    else
    {
        rear=(rear+1)%MAX_QUEUE_SIZE;
        array[rear]=value;
    }


}

template<class T> void circular_Queue<T>::pop()
{
    if (isEmpty())
    {
        cerr<<"queue empty"<<endl;
    }
    else
    {
        front=(front+1)%MAX_QUEUE_SIZE;
    }
}


template<class T> T circular_Queue<T>::Front()
{
    if (isEmpty())
    {
        cerr<<"queue empty"<<endl;
        return 0;
    }
    else
    {
        return array[(front+1)%MAX_QUEUE_SIZE];
    }

}
template<class T>void circular_Queue<T>::clear()
{
    front=rear=0;
}

3.链队列实现

/************************************************************************/
/* 队列：链表实现                                                       */
/************************************************************************/

template<typename T> class Queue_list
{
    public:
        Queue_list():front(0),rear(0){}
        void pop();
        void push(T);
        void clear();
        T Front();
        bool isEmpty();
        bool isFull();
    private:
        list_node<T> *front,*rear;
        
};

template<typename T> bool Queue_list<T>::isEmpty()
{
    if(front==NULL)
        return true;
    else
        return false;
}

template<typename T>bool Queue_list<T>::isFull()
{

}

template<typename T> void Queue_list<T>::push(T value)
{
    list_node<T> * p=new list_node<T>;
    if (p==NULL)
    {
        cerr<<"new error, queue full"<<endl;
    }
    else
    {
        p->value=value;
        p->next=NULL;
        if (front==NULL)
        {
            front=p;
            rear=p;
        }
        else
        {
            rear->next=p;
            rear=p;
        }
    }


}

template<class T> void Queue_list<T>::pop()
{
    if(isEmpty())
    {
        cerr<<"queue empty"<<endl;
    }
    else
    {
        list_node<T> *p=front;
        front=front->next;
        delete p;

    }
    
}

template<class T> T Queue_list<T>::Front()
{
    if (isEmpty())
    {
        cerr<<"queue empty"<<endl;
        return 0;
    }
    else
    {
        return front->value;
    }
}

template<typename T> void Queue_list<T>::clear()
{
    while(!isEmpty())
    {
        pop();
    }

}