C++模版类实现循环队列和链式队列并利用队列打印二项式展开系数

1、Queue.h

#ifndef Queue_h
#define Queue_h
const int maxSize = 50;
template <class T>
class Queue{
public:
    Queue(){}
    virtual ~Queue(){}
    virtual bool EnQueue(const T& x) = 0;
    virtual bool DeQueue(T& x) = 0;
    virtual bool getFront(T& x)const = 0;
    virtual bool IsEmpty()const = 0;
    //virtual bool IsFull()const = 0;
    virtual int getSize()const = 0;
};

#endif /* Queue_h */

2、SeqQueue.h

#ifndef SeqQueue_h
#define SeqQueue_h
#include <assert.h>
#include <iostream>
#include "Queue.h"
using std::ostream;

template <class T>
class SeqQueue : public Queue<T>{
private:
    int rear, front;
    T* elements;
    int maxSize;
public:
    SeqQueue(int sz = 10);
    ~SeqQueue(){delete []elements;}
    bool EnQueue(const T& x);
    bool DeQueue(T& x);
    bool getFront(T& x)const;
    void makeEmpty(){front = rear = 0;}
    bool IsEmpty()const{return (front == rear) ? true:false;}
    bool IsFull()const{return ((rear+1)%maxSize == front) ? true:false;}
    int getSize()const{return (rear-front+maxSize)%maxSize;}
    template <class U> friend ostream& operator<<(ostream& os, SeqQueue<U>& q);
};

#endif /* SeqQueue_h */

3、SeqQueue.cpp

#include <stdio.h>
#include "SeqQueue.h"
using std::endl;

template <class T>
SeqQueue<T>::SeqQueue(int sz) : front(0), rear(0), maxSize(sz){
    elements = new T[maxSize];
    assert(elements != NULL);
}

template <class T>
bool SeqQueue<T>::EnQueue(const T &x){
    if(IsFull() == true)
        return false;
    elements[rear] = x;
    rear = (rear+1) % maxSize;
    return true;
}

template <class T>
bool SeqQueue<T>::DeQueue(T &x){
    if(IsEmpty() == true)
        return false;
    x = elements[front];
    front = (front+1) % maxSize;
    return true;
}

template <class T>
bool SeqQueue<T>::getFront(T &x)const{
    if(IsEmpty() == true)
        return false;
    x = elements[front];
    return true;
}

template <class T>
ostream& operator<<(ostream& os, SeqQueue<T>& q){
    os << "front = " << q.front << ", rear = " << q.rear << endl;
    for(int i = q.front; i != q.rear; i = (i+1) % q.maxSize)
    os << i << ":" << q.elements[i] << endl;
    return os;
}

4、LinkedQueue.h

#ifndef LinkedQueue_h
#define LinkedQueue_h
#include <iostream>
#include "Queue.h"
using std::ostream;

template <class T>
struct LinkNode{
    T data;
    LinkNode<T>* link;
    LinkNode(LinkNode<T>* ptr = NULL) : link(ptr){}
    LinkNode(const T& item, LinkNode<T> *ptr = NULL) : data(item), link(ptr){}
};

template <class T>
class LinkedQueue : public Queue<T>{
private:
    LinkNode<T>* front, * rear;
public:
    LinkedQueue() : rear(NULL), front(NULL){}
    ~LinkedQueue(){makeEmpty();}
    bool EnQueue(const T& x);
    bool DeQueue(T& x);
    bool getFront(T& x)const;
    void makeEmpty();
    bool IsEmpty()const{return (front == NULL) ? true:false;}
    int getSize()const;
    template <class U> friend ostream& operator<<(ostream& os, LinkedQueue<U>& q);
};

#endif /* LinkedQueue_h */

5、LinkedQueue.cpp

#include <stdio.h>
#include "LinkedQueue.h"
using std::endl;

template <class T>
void LinkedQueue<T>::makeEmpty(){
    LinkNode<T>* p;
    while(front != NULL){
        p = front;
        front = front->link;
        delete p;
    }
}

template <class T>
bool LinkedQueue<T>::EnQueue(const T &x){
    if(front == NULL){
        front = rear = new LinkNode<T>(x);
        if(front == NULL)
            return false;
    }
    else{
        rear->link = new LinkNode<T>(x);
        if(rear->link == NULL)
            return false;
        rear = rear->link;
    }
    return true;
}

template <class T>
bool LinkedQueue<T>::DeQueue(T &x){
    if(IsEmpty() == true)
        return false;
    LinkNode<T>* p = front;
    x = p->data;
    front = front->link;
    delete p;
    return true;
}

template <class T>
bool LinkedQueue<T>::getFront(T &x)const{
    if(IsEmpty() == true)
        return false;
    x = front->data;
    return true;
}

template <class T>
int LinkedQueue<T>::getSize()const{
    LinkNode<T>* p = front;
    int count = 0;
    while(p != NULL){
        p = p->link;
        count ++;
    }
    return count;
}

template <class T>
ostream& operator<<(ostream& os, LinkedQueue<T>& q){
    os << "队列中元素个数有" << q.getSize() << endl;
    LinkNode<T>* p = q.front;
    int i = 0;
    while(p != NULL){
    os << ++i << ":" << p->data << endl;
    p = p->link;
    }
    return os;
}

6、main.cpp

#include <iostream>
#include "LinkedQueue.cpp"
#include "SeqQueue.cpp"
using std::endl;
using std::cout;

void YANGVI(int n){
    SeqQueue<int> q(n+2);
    int i = 1, j, s = 0, k = 0, t, u;
    q.EnQueue(i);
    q.EnQueue(i);
    for(i = 1; i <= n; i ++){
        cout << endl;
        q.EnQueue(k);
        for(j = 1; j <= i+2; j ++){
            q.DeQueue(t);
            u = s+t;
            q.EnQueue(u);
            s = t;
            if(j != i+2)
                cout << s << ' ';
        }
    }
}

int main(){
    YANGVI(6);
    return 0;
}