栈与队列

栈与队列的基本操作

栈的类定义

template <class T>
class Stack
{
public:
    Stack(){}
    void Push(T &x);
    void Pop(T &x);
    bool IsEmpty();
    bool IsFull();
private:
    T *elements;
    int top;
    int maxSize;
}

顺序栈的类定义

template <class T>
class SeqStack : public Stack<T>
{
private:
    T *elements;
    int top;
    int maxSize;
public:
    SeqStack(){};   /*构造函数*/
    void Push(T &x);
    T Pop(T &x);
    bool IsEmpty();
    bool IsFull();
    int getSize();

}

template <class T>
SeqStack<T>::SeqStack(int size):top(-1),maxSize(size)
{
    elements = new T[maxSize];
}

template <class T>
void SeqStack<T> :: Push(T &x)
{
    if(IsFull() == true)
        return;
    elements[++top] = x;
}

template <class T>
T SeqStack<T :: Pop(T &x)
{
    if(IsEmpty() == true)
        return;
    x = elements[top--];
    return x;
}

template <class T>
bool SeqStack :: IsEmpty()
{
    return (top == -1) ? true:false;
}

template <class T>
bool SeqStack :: IsFull()
{
    return (top == maxSize-1) ? true:false;
}

链式栈的类定义

template <class T>
class LinkedStack : public Stack<T>
{
private:
    LinkNode<T> *top;
public:
    LinkedStack(){}     /*构造函数*/
    void Push(T &x);
    T Pop(T &x);
    bool IsEmpty();
    int getSize();
    void makeEmpty();
}

template <class T>
int LinkedStack<T> :: getSize()
{
    LinkNode<T> *p = top;
    int count = 0;
    while(p != NULL)
    {
        k++;
        p = p -> next;
    }
    return k;
}

template <class T>
void LinkedStack<T> :: makeEmpty()
{
    LinkNode<T> *p;
    while(top != NULL)
    {
        p = top;
        top = top -> next;
        delete p;
    }
}

template <class T>
void LinkedStack<T> :: Push(T &x)
{
    top = new StackNode<T>(x,top); /*创建新结点*/
}

template <class T>
T LinkedStack<T> :: Pop(T &x)
{
    LinkNode<T> *p = top;
    top = top -> next; /*链式栈的删除和插入操作都在表头进行*/
    x = top -> data;
    delete p;
    return x;
}

栈与递归

斐波那契数列的递归算法

long Fib(long n)
{
    if(n <= 1)
        return n;
    else
        return Fib(n-1) + Fib(n-2);
}

打印链表最后一个结点的数据

template <class T>
void Print(ListNode<T> *p)
{
    if(p -> next == NULL)
        cout << p -> data <<endl;
    else
        Print(p -> next);
}

• A[n] 为一整型数组*

int FindMax(int n)
{
    if(n == 1)
        return A[0];
    int temp = FindMax(n-1);
    if(A[n-1] > temp)
        return A[n-1];
    else
        return temp;
}

int Sum(int n)
{
    if(n == 1)
        return A[0];
    else
        return A[n-1] + Sum(n-1);
}

double Average(int n)
{
    if(n == 1)
        return (double)A[0];
    else
        return ((double)A[n-1] + (n-1)*Average(n-1))/n;
}

队列

template<class T>
class Queue
{
public:
    Queue(){}
    void EnQueue(T &x);
    T DeQueue(T &x);
    bool IsEmpty();
    bool IsFull();
}

顺序队列的类定义

template<class T>
class SeqQueue : public Queue<T>
{
private:
    int rear, front;
    T *elements;
    int maxSize;
public:
    SeqQueue(int size){}
    void EnQueue(T &x);
    T DeQueue(T &x);
    bool IsEmpty();
    bool IsFull();
    int getSize();
}

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

template <class T>
void SeqQueue<T>::EnQueue(T &x)
{
    elements[rear] = x;
    rear = (rear + 1) % maxSize;
}

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

链式队列的定义

template <class T>
class LinkedQueue
{
private:
    LinkNode<T> *front, *rear;
public:
    LinkedQueue():rear(NULL),front(NULL)
    {}
    void EnQueue(T &x);
    T DeQueue(T &x);
    void makeEmpty();
    bool IsEmpty(){return front == NULL}
}

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

template <class T>
void LinkedQueue<T>::EnQueue(T &x)
{
    if(front == NULL) /*创建第一个结点*/
        front = rear = new LinkNode<T>(x);
    else
    {
        rear -> next = new LinkNode<T>(x);
        rear = rear -> next;
    }
}

template <class T>
T LinkNode<T>::DeQueue(T &x)
{
    LinkNode<T *p;
    p = front;
    x = front -> data;
    front = front -> next;
    delete p;
    return x;
}

利用队列打印杨辉三角

void print_Triangle(int n)
{  
    Queue<int>q;  
    //for(int i=0;i<2*n-1;i++)   //控制输出，美观  
        cout<<" ";  
    cout<<1<<" "<<endl;     //输出第一行的1  
    q.EnQueue(1);  
    int s1,s2;  
    for(int i=2;i<=n;i++)
    {  

        /*for(int k=0;k<2*n-i;k++)    //控制输出，美观  
            cout<<" ";*/  
        s1 = 0;  
        for(int j=1;j<=i-1;j++)
        {  
            s2 = q.front();  
            q.DeQueue();         //出队  
            cout<<s1+s2<<" ";  
            q.EnQueue(s1+s2);  
            s1 = s2;         //s1保留的是前一个数  
        }  
        cout<<1<<endl;      //输出每行最后一个1  
        q.EnQueue(1);
    }  
}