C++ 双向队列链式实现和队列的顺序实现

1.双向队列采用双向链表实现

转载
双向队列采用双向链表实现

#ifndef _DEQUEUE_H
#define _DEQUEUE_H

typedef int DataType; 

class Node
{
private: 
    DataType data;
public:
    Node *next;
    Node *prior;
    Node(DataType val);
    ~Node();
    DataType get_data();
};

class DeQueue
{
private:
    Node *begin;//指向队头
    Node *end;//指向队尾
public:
    DeQueue();
    ~DeQueue();
    int push_back(DataType val);//在队尾添加一个元素
    int pop_back();//在队尾删除一个元素
    int push_front(DataType val);//在队头添加一个元素
    int pop_front();//在队头删除一个元素
    int empty();//队列为空时返回1
    void print();
};

#endif

dequeue.cpp

#include "dequeue.h"
#include <iostream>

Node::Node(DataType val)
{
    data = val;
    next = 0;
    prior = 0;
}

Node::~Node()
{}

DataType Node::get_data()
{
    return data;
}

DeQueue::DeQueue()
{
    begin = 0;
    end = 0;
}

DeQueue::~DeQueue()
{}

int DeQueue::push_back(DataType val)
{
    Node *node = new Node(val);
    if(empty())//链表为空时
    {   
        begin = end = node;
        return 0;
    }
    end->next = node;
    node->prior = end;
    end = node;
    return 0;
}

int DeQueue::pop_back()
{
    if(empty())
        return -1;
    Node *p = end;
    if(!begin->next)//链表只有一个节点时
    {
        delete p;
        begin = end = 0;
        return 0;
    }   
    end = end->prior;
    end->next = 0;
    delete p;
    return 0;
}

int DeQueue::push_front(DataType val)
{
    Node *node = new Node(val);
    if(empty())//链表为空时
    {   
        begin = end = node;
        return 0;
    }
    node->next = begin;
    begin->prior = node;
    begin = node;
    return 0;
}

int DeQueue::pop_front()
{
    if(empty())
        return -1;
    Node *p = begin;
    if(!begin->next)//只有一个节点时
    {
        delete p;
        begin = end = 0;
        return 0;
    }
    begin->next->prior = 0;
    begin = begin->next;
    delete p;
    return 0;
}

int DeQueue::empty()
{
    if((end == begin) && (0 == end))//链表为空时
        return 1;
    return 0;
}

void DeQueue::print()
{
    Node *p = begin;
    std::cout<<"print :"<<std::endl;
    while(p)
    {
        std::cout<<p->get_data()<<" "<<std::endl;
        p = p->next;
    }
    p = end;
    std::cout<<"print reverse:"<<std::endl;
    while(p)
    {
        std::cout<<p->get_data()<<" "<<std::endl;
        p = p->prior;
    }
}

2.顺式队列采用数组实现

queue.h

#ifndef _QUEUE_H
#define _QUEUE_H

#define MAX_SIZE 4
typedef int DataType;

class Queue
{
private:
    DataType q[MAX_SIZE];
    int currentSize;//记录当前队列含有的数目
    int front;//记录队头位置
    int end;//记录队尾位置的后面一位
public:
    Queue();
    ~Queue();
    int empty();//队列为空时返回1
    int dequeue();//从队头出队
    int enqueue(DataType val);//从队尾入队
    int full();//队列满时返回1
    DataType queue_front();//获取队首元素
    DataType queue_end();//获取队尾元素
    void print();
};

#endif

queue.cpp

#include "queue.h"
#include <iostream>

Queue::Queue()
{
    currentSize = 0;
    front = 0;
    end = 0;
}

Queue::~Queue()
{}

int Queue::empty()
{
    if(0 == currentSize)
        return 1;
    return 0;
}

int Queue::dequeue()
{
    if(empty())//队列为空时
        return -1;
    q[front] = 0;
    front++;
    currentSize--;
    if(front == MAX_SIZE)
        front = 0;
    return 0;
}

int Queue::enqueue(DataType val)
{
    if(full())
        return -1;
    q[end] = val;
    end++;
    currentSize++;
    if(end == MAX_SIZE)
        end = 0;
    return 0;
}

int Queue::full()
{
    if(currentSize == MAX_SIZE)
        return 1;
    return 0;
}

DataType Queue::queue_front()
{
    return q[front];
}

DataType Queue::queue_end()
{
    return q[end-1];
}

void Queue::print()
{
    std::cout<<"the elements of the queue is :"<<std::endl;
    for(int i = front; i != end; i++)
    {
        if(i == MAX_SIZE)
            i = 0;
        std::cout<<q[i]<<" ";
    }
    std::cout<<std::endl;
}