栈,队列,二叉树的类模板及操作

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <time.h>
#include <iomanip>
#include <math.h>
using namespace std;

template <class ElementType>
class Stack
{
public:
    struct LinkNode
    {
        ElementType Element;
        LinkNode* Next;
    };
    typedef LinkNode* List;
private:
    int NodeNumbers;
    List L;
public:
    Stack()
    {
        NodeNumbers = 0;
        L = new LinkNode;
        L->Next = NULL;
        L->Element = NULL;
    }
    ~Stack()
    {
        if (IsEmpty())
            return;
        while (L->Next != NULL)
        {
            List P = L->Next;
            L->Next = P->Next;
            delete P;
        }
        delete L;
    }
    bool IsEmpty()
    {
        return L->Next == NULL;
    }
    void Push(ElementType X)
    {
        List Cell = new LinkNode;
        Cell->Element = X;
        Cell->Next = L->Next;
        L->Next = Cell;
        NodeNumbers++;
    }
    ElementType Pop()
    {
        if (IsEmpty())
        {
            cout << "Empty Stack!" << endl;
            return NULL;
        }
        List TmpCell = L->Next;
        L->Next = TmpCell->Next;
        ElementType Tmp = TmpCell->Element;
        delete TmpCell;
        NodeNumbers--;
        return Tmp;
    }
    int GetNodeNumbers()
    {
        return NodeNumbers;
    }
};

template <class ElementType>
class BinTree
{
public:
    struct TreeNode
    {
        ElementType Key;
        TreeNode *Left, *Right;
    };
    typedef TreeNode* Tree;
private:
    Tree T;
    int NodeNumbers;
public:
    BinTree(ElementType X)
    {
        T = new TreeNode;
        T->Key = X;
        T->Right = T->Left = NULL;
        NodeNumbers=0;
    }
    ~BinTree()
    {
        DestroyTree(T);
    }
    Tree Find(ElementType X)//套壳
    {
        return CFind(T, X);
    }
    void Insert(ElementType X)
    {
        CInsert(T, X);
        NodeNumbers++;
    }
    void Delete(ElementType X)
    {
        CDelete(T, X);
        NodeNumbers--;
    }
    Tree FindMin()
    {
        return CFindMin(T);
    }
    Tree GetRoot()
    {
        return T;
    }
    void PreOrder()
    {
        CPreorder(T);
    }
    int GetNodeNumbers()
    {
        return NodeNumbers;
    }
    void LayerOrder()//层序遍历   将根节点入队,然后开始执行循环:节点出队,访问该节点,其左右儿子入队
    {
        Quene<Tree> Q(NodeNumbers);
        Q.EnQuene(T);
        while (!Q.IsEmpty())//队列为空时结束循环
        {
            Tree P = Q.DeQuene();
            cout << P->Key << endl;
            if (P->Left)
                Q.EnQuene(P->Left);
            if (P->Right)
                Q.EnQuene(P->Right);
          }
    }
    void InOrder()//中序遍历 非递归
    {
        /*
        1. 遇到一个节点,就把它压栈,并去遍历它的左子树
        2. 当左子树遍历结束后,从栈中弹出这个元素并访问它
        3. 然后按其右指针再去中序遍历该节点的右子树
        */           
        Stack<Tree> S;
        Tree P = T;
        while (P || !S.IsEmpty())
        {
            while (P)
            {
                S.Push(P);
                P = P->Left;
            }
            if (!S.IsEmpty())
            {
                P = S.Pop();//节点弹出堆栈      欲实现先序遍历,可将这句移至S.Push(P)后
                cout << P->Key << endl;//打印节点
                P = P->Right;//转向右子树
            }
        }
    }
    void Postorder()
    {
        CPostorder(T);
    }
private:
    Tree CFind(Tree T, ElementType X)
    {
        if (T == NULL)
            return NULL;
        else if (X == T->Key)
            return T;
        else if (X < T->Key)
            return CFind(T->Left, X);
        else if(X>T->Key)
            return CFind(T->Right, X);
    }
    Tree CInsert(Tree T, ElementType X)
    {
        if (T == NULL)
        {
            T = new TreeNode;
            T->Key = X;
            T->Left = T->Right = NULL;
        }
        else if (X < T->Key)
            T->Left = CInsert(T->Left, X);
        else if (X > T->Key)
            T -> Right = CInsert(T->Right, X);
        return T;
    }
    Tree CDelete(Tree T, ElementType X)
    {
        if (T == NULL)
        {
            cout << "No such Element!" << endl;
            return NULL;
        }
        else if (X < T->Key)
            T->Left = CDelete(T->Left, X);
        else if (X > T->Key)
            T->Right = CDelete(T->Right, X);
        else if (T->Left&&T->Right)//two children
        {
            Tree Tmp = CFindMin(T->Right);
            T->Key = Tmp->Key;
            T->Right=CDelete(T->Right, T->Key);
        }
        else //one or zero child
        {
            Tree Tmp = T;
            if (T->Left == NULL)
                T = T->Right;
            else if (T->Right == NULL)
                T = T->Left;
            delete Tmp;
        }
        return T;
    }
    Tree CFindMin(Tree T)
    {
        if (T == NULL)
            return NULL;
        else if (T->Left == NULL)
            return T;
        else
            return CFindMin(T->Left);
    }
    void DestroyTree(Tree T)
    {
        if (T != NULL)
        {
            DestroyTree(T->Left);
            DestroyTree(T->Right);
            Delete(T->Key);
        }
    }
    void CPreorder(Tree T)
    {
        if (T != NULL)
        {
            cout << T->Key << endl;
            CPreorder(T->Left);
            CPreorder(T->Right);
        }
    }
    void CPostorder(Tree T)
    {
        if (T != NULL)
        {
            CPostorder(T->Left);
            CPostorder(T->Right);
            cout << T->Key << endl;
        }
    }
};

template<class ElementType>
class Quene
{
private:
    ElementType* Array;
    int Size;
    int Capacity;
    int Front, Rear;
public:
    Quene(int Capacity)
    {
        Array = new ElementType[Capacity];
        this->Capacity = Capacity;
        Size = 0;
        Front = 1;
        Rear = 0;
    }
    Quene()
    {
        Capacity = 20;
        Array = new ElementType[Capacity];
        Size = 0;
        Front = 1;
        Rear = 0;
    }
    ~Quene()
    {
        delete[]Array;
    }
    bool IsFull()
    {
        return Size == Capacity;
    }
    bool IsEmpty()
    {
        return Size == 0;
    }
    void EnQuene(ElementType X)
    {
        if (IsFull())
        {
            cout << "Full quene!" << endl;
            return;
        }
        Size++;
        Rear = (++Rear) % Capacity;
        Array[Rear] = X;
    }
    ElementType DeQuene()
    {
        if (IsEmpty())
        {
            cout << "Empty quene!" << endl;
            return NULL;
        }
        ElementType Ret = Array[Front];
        Front = (++Front) % Capacity;
        Size--;
        return Ret;
    }
    void Show()
    {
        for (int i = 0; i < Size; i++)
        {
            cout << Array[(Front + i) % Capacity] << " ";
        }
        cout << endl;
    }
};
int main()
{
    int Array[] = { 5,15,3,7,13,19,2,4,6,8,12,14,18,20 };
    int N = sizeof(Array) / sizeof(int);
    BinTree<int> T(10);
    for (int i = 0; i < N; i++)
    {
        T.Insert(Array[i]);
    }
    T.InOrder();
    cout << endl << endl;
    T.PreOrder();
    cout << endl << endl;
    T.Postorder();
    return 0;
}