【数据结构】二叉树

谨以此文记录二叉树的实现：

#include <iostream>

using namespace std;

#define MAXSIZE 100

//二叉树
typedef char TElemType;
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

//顺序栈
typedef BiTree SElemType;
typedef struct
{
    SElemType *base = nullptr;
    SElemType *top = nullptr;
    int stacksize;
} SqStack;

//链队列
typedef BiTree QElemType;
typedef struct QNode
{
    QElemType data;
    QNode *next;
} QNode, *QueuePtr;

typedef struct
{
    QueuePtr front = nullptr, rear = nullptr;
} LinkQueue;

/**
 * @brief 初始化栈
 *
 * @param S
 * @return true
 * @return false
 */
bool InitStack(SqStack &S)
{
    S.base = new SElemType[MAXSIZE];
    S.top = S.base;
    S.stacksize = MAXSIZE;
    return true;
}

/**
 * @brief 销毁栈
 *
 * @param S
 * @return true
 * @return false
 */
bool DestroyStack(SqStack &S)
{
    if (S.base)
    {
        delete[] S.base;
        S.stacksize = 0;
        S.base = S.top = nullptr;
    }
    return true;
}

/**
 * @brief 入栈
 *
 * @param S
 * @param e
 * @return true
 * @return false
 */
bool Push(SqStack &S, SElemType e)
{
    if (S.top - S.base == S.stacksize)
        return false;
    *S.top++ = e;
    return true;
}

/**
 * @brief 出栈
 *
 * @param S
 * @param e
 * @return true
 * @return false
 */
bool Pop(SqStack &S, SElemType &e)
{
    if (S.top == S.base)
        return false;
    e = *--S.top;
    return true;
}

/**
 * @brief 判断栈是否为空
 *
 * @param S
 * @return true
 * @return false
 */
bool StackEmpty(SqStack S)
{
    if (S.top == S.base)
        return true;
    return false;
}

/**
 * @brief 初始化队列
 *
 * @param Q
 * @return true
 * @return false
 */
bool InitQueue(LinkQueue &Q)
{
    Q.front = Q.rear = new QNode;
    Q.front->next = nullptr;
    return true;
}

/**
 * @brief 销毁队列
 *
 * @param Q
 * @return true
 * @return false
 */
bool DestroyQueue(LinkQueue &Q)
{
    while (Q.front)
    {
        Q.rear = Q.front->next;
        delete Q.front;
        Q.front = Q.rear;
    }
    return true;
}

/**
 * @brief 判断队列是否为空
 *
 * @param Q
 * @return true
 * @return false
 */
bool QueueEmpty(LinkQueue Q)
{
    return Q.front == Q.rear;
}

/**
 * @brief 入队
 *
 * @param Q
 * @param e
 * @return true
 * @return false
 */
bool EnQueue(LinkQueue &Q, QElemType e)
{
    QNode *p = new QNode;
    p->data = e;
    p->next = nullptr;
    Q.rear->next = p;
    Q.rear = p;
    return true;
}

/**
 * @brief 出队
 *
 * @param Q
 * @param e
 * @return true
 * @return false
 */
bool DeQueue(LinkQueue &Q, QElemType &e)
{
    if (Q.front == Q.rear)
        return false;
    QNode *p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if (Q.rear == p)
        Q.rear = Q.front;
    delete p;
    return true;
}

void printUI()
{
    cout << "*******************************************************" << endl;
    cout << "*********  1.创建二叉树                       *********" << endl;
    cout << "*********  2.先序遍历二叉树                   *********" << endl;
    cout << "*********  3.中序遍历二叉树1                  *********" << endl;
    cout << "*********  4.中序遍历二叉树2                  *********" << endl;
    cout << "*********  5.后序遍历二叉树                   *********" << endl;
    cout << "*********  6.层序遍历二叉树                   *********" << endl;
    cout << "*********  7.求二叉树的深度                   *********" << endl;
    cout << "*********  8.退出                             *********" << endl;
    cout << "*******************************************************" << endl;
}

/**
 * @brief 先序遍历创建二叉树
 *
 * @param T
 */
void CreateBiTree(BiTree &T)
{
    char ch;
    cin >> ch;
    if (ch == '$')
        T = nullptr;
    else
    {
        T = new BiTNode;
        T->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
}

/**
 * @brief 先序遍历二叉树
 *
 * @param T
 */
void PreOrderTraverse(BiTree T)
{
    if (T)
    {
        cout << T->data << " ";
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}

/**
 * @brief 中序遍历二叉树（递归）
 *
 * @param T
 */
void InOrderTraverse1(BiTree T)
{
    if (T)
    {
        InOrderTraverse1(T->lchild);
        cout << T->data << " ";
        InOrderTraverse1(T->rchild);
    }
}

/**
 * @brief 中序遍历二叉树（非递归）
 *
 * @param T
 */
void InOrderTraverse2(BiTree T)
{
    SqStack S;
    InitStack(S);
    BiTree p = T, q;
    while (p || !StackEmpty(S))
    {
        if (p)
        {
            Push(S, p);
            p = p->lchild;
        }
        else
        {
            Pop(S, q);
            cout << q->data << " ";
            p = q->rchild;
        }
    }
    DestroyStack(S);
}

/**
 * @brief 后序遍历二叉树
 *
 * @param T
 */
void PostOrderTraverse(BiTree T)
{
    if (T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout << T->data << " ";
    }
}

/**
 * @brief 层序遍历二叉树
 *
 * @param T
 */
void LevelOrderTraver(BiTree T)
{
    LinkQueue Q;
    InitQueue(Q);
    EnQueue(Q, T);
    while (!QueueEmpty(Q))
    {
        BiTree p;
        DeQueue(Q, p);
        cout << p->data << " ";
        if (p->lchild)
            EnQueue(Q, p->lchild);
        if (p->rchild)
            EnQueue(Q, p->rchild);
    }
    DestroyQueue(Q);
}

/**
 * @brief 求二叉树深度
 *
 * @param T
 * @return int
 */
int Depth(BiTree T)
{
    if (T == nullptr)
        return 0;
    else
    {
        int m = Depth(T->lchild);
        int n = Depth(T->rchild);
        if (m >= n)
            return m + 1;
        else
            return n + 1;
    }
}

int main()
{
    BiTree T = nullptr;
    int mode;
    printUI();
    while (true)
    {
        cout << "请输入选择：";
        cin >> mode;
        if (mode == 8)
            break;
        if (mode < 1 || mode > 8)
            continue;
        if (!T && mode != 1)
        {
            cout << "尚未初始化" << endl;
            continue;
        }
        switch (mode)
        {
        case 1:
            cout << "请输入节点序列：";
            CreateBiTree(T);
            cout << "创建成功" << endl;
            break;
        case 2:
            PreOrderTraverse(T);
            cout << endl;
            break;
        case 3:
            InOrderTraverse1(T);
            cout << endl;
            break;
        case 4:
            InOrderTraverse2(T);
            cout << endl;
            break;
        case 5:
            PostOrderTraverse(T);
            cout << endl;
            break;
        case 6:
            LevelOrderTraver(T);
            cout << endl;
            break;
        case 7:
            cout << "二叉树深度为" << Depth(T) << endl;
            break;
        }
    }
    return 0;
}