数据结构——队列

循环队列

#include <iostream>
#include <cassert>
using namespace std;
typedef int dt;
const int maxSize = 50;
class Queue {
public:
    Queue(){}
    ~Queue(){}
    virtual void EnQueue(const dt& x) = 0;
    virtual bool DeQueue(dt& x) = 0;
    virtual bool GetFront(dt& x) = 0;
    virtual bool IsEmpty()const = 0;
    virtual bool IsFull()const = 0;
    virtual int getSize() = 0;
};
class SeqQueue :public Queue {
public:
    SeqQueue(int sz = 10) :front(0), rear(0), maxSize(sz) {
        elements = new dt[maxSize];
        assert(elements != NULL);
    }
    ~SeqQueue() { delete[]elements; }
    virtual void EnQueue(const dt& x) ;
    virtual bool DeQueue(dt& x) ;
    void makeEmpty() { front = rear = 0; }
    virtual bool GetFront(dt& x) ;
    virtual bool IsEmpty()const { return front == rear ? 1 : 0; }
    virtual bool IsFull()const { return (rear + 1) % maxSize == front ? 1 : 0; }
    virtual int getSize() { return (rear - front + maxSize) % maxSize; }
    friend ostream& operator<<(ostream& os, SeqQueue& q);
protected:
    int rear, front;
    dt* elements;
    int maxSize;
};
void SeqQueue::EnQueue(const dt& x) {
    if (IsFull())return;
    elements[rear] = x;
    rear = (rear + 1) % maxSize;
    return ;
 }
bool SeqQueue::DeQueue(dt& x) {
    if (IsEmpty())return 0;
    x = elements[front];
    front = (front + 1) % maxSize;
    return 1;
 }
bool SeqQueue::GetFront(dt& x) {
    if (IsEmpty())return 0;
    x = elements[front];
    return 1;
 }
ostream& operator<<(ostream& os, SeqQueue& q) {
    os << "front=" << q.front << ",rear=" << q.rear << endl;
    for (int i = q.front; i != q.rear; i = (i + 1) % maxSize)
        os << i << ":" << q.elements[i] << endl;
    return os;
 }
int main()
{
    SeqQueue sq;
    int x;
    sq.EnQueue(10);
    cout << sq;
    sq.DeQueue(x);
    cout << sq;
    cout << sq.IsEmpty() << endl;
    sq.EnQueue(1);
    sq.EnQueue(2);
    sq.EnQueue(3);
    sq.EnQueue(4);
    sq.EnQueue(5);
    cout << sq;
}

链式队列

#include <iostream>
#include <cassert>
using namespace std;
typedef int dt;
const int maxSize = 50;
class Node {
public:
    Node* link;
    dt data;
    Node(Node* ptr = NULL) { link = ptr; }
    Node(const dt& item, Node* ptr = NULL) { data = item, link = ptr; }
};
class Queue {
public:
    Queue() {}
    ~Queue() {}
    virtual void EnQueue(const dt& x) = 0;
    virtual bool DeQueue(dt& x) = 0;
    virtual bool GetFront(dt& x)const = 0;
    virtual bool IsEmpty()const = 0;
    virtual int getSize()const = 0;
};
class LinkQueue :public Queue {
public:
    LinkQueue() :front(NULL), rear(NULL) {}
    ~LinkQueue() { makeEmpty(); }
    virtual void EnQueue(const dt& x);
    virtual bool DeQueue(dt& x);
    void makeEmpty();
    virtual bool GetFront(dt& x)const;
    virtual bool IsEmpty()const { return front == NULL ? 1 : 0; }
    virtual int getSize() const;
    friend ostream& operator<<(ostream& os, LinkQueue& q);
protected:
    Node* rear, * front;
};
void LinkQueue::makeEmpty() {
    Node* p;
    while (front) {
        p = front;
        front = front->link;
        delete p;
    }
}
void LinkQueue::EnQueue(const dt& x) {
    if (front == NULL) {
        front = rear = new Node(x);
        if (front == NULL)return ;
    }
    else {
        rear->link = new Node(x);
        if (rear->link == NULL)return;
        rear = rear->link;
    }
    return;
}
bool LinkQueue::DeQueue(dt& x) {
    if (IsEmpty())return 0;
    Node* p = front;
    x = front->data;
    front = front->link;
    delete p;
    return 1;
}
bool LinkQueue::GetFront(dt& x)const {
    if (IsEmpty())return 0;
    x = front->data;
    return 1;
}
int LinkQueue::getSize()const {
    Node* p = front; int k=0;
    while (p) {
        p = p->link;
        k++;
    }
    return k;
}
ostream& operator<<(ostream& os, LinkQueue& q) {
    os << "个数=" << q.getSize() << endl;
    Node* p = q.front; int i = 0;
    while (p) {
        os << "第" << ++i << ":" << p->data << endl;
        p = p->link;
    }
    return os;
}
int main()
{
    LinkQueue sq;
    int x;
    sq.EnQueue(10);
    cout << sq;
    sq.DeQueue(x);
    cout << sq;
    cout << sq.IsEmpty() << endl;
    sq.EnQueue(1);
    sq.EnQueue(2);
    sq.EnQueue(3);
    sq.EnQueue(4);
    sq.EnQueue(5);
    cout << sq;
}