二叉树的遍历,销毁,高度

#include <iostream>
#include <stack>
#include <queue>
#include <stdlib.h>

using namespace std;

typedef struct BiTNode{
    int data;
    bool postOrderFlag; //true 表示已经遍历过
    BiTNode*lchild;
    BiTNode*rchild;
}BiTNode;

BiTNode *NewTreeNode(int val) {
    BiTNode *tr = (BiTNode *) malloc(sizeof(BiTNode));
    tr->data = val;
    tr->lchild = NULL;
    tr->rchild = NULL;
    return tr;
}

//创建二叉树
BiTNode *CreateTree() {

    BiTNode *tr;
    int val;
    cin >> val;
    if (val == 0)//.代表空子树
        tr = NULL;
    else {
        tr = (BiTNode *) malloc(sizeof(BiTNode));
        if (!tr) {
            cout << "开辟内存失败" << endl;
            exit(1);
        }
        tr->data = val;//给T赋值
        tr->lchild = CreateTree();//给左子树赋值
        tr->rchild = CreateTree();//给右子树赋值
    }
    return tr;
}

//先序递归遍历：根左右
void PreOrderTraverseRecursive(BiTNode *tr) {
    if (tr == NULL) {
        return;
    }

    //printf("%d ",tr->data);
    cout << tr->data << endl;
    PreOrderTraverseRecursive(tr->lchild);
    PreOrderTraverseRecursive(tr->rchild);
}

//先序非递归遍历:根左右
void PreOrderTraverse(BiTNode *tr) {

    if (tr == NULL) {
        return;
    }

    stack<BiTNode *> st;
    st.push(tr);
    while (!st.empty()) {
        BiTNode *p = st.top();
        st.pop();
        while (p != NULL) {
            cout << p->data << endl;
            if (p->rchild != NULL) {
                st.push(p->rchild);
            }
            p = p->lchild;
        }
    }
}

//中序递归遍历:左根右
void InOrderTraverseRecursive(BiTNode *tr) {
    if (tr == NULL) {
        return;
    }

    InOrderTraverseRecursive(tr->lchild);
    cout << tr->data << endl;
    InOrderTraverseRecursive(tr->rchild);
}

//中序非递归遍历:左根右
void InOrderTraverse(BiTNode *tr) {

    if (tr == NULL) {
        return;
    }

    stack<BiTNode *> st;
    BiTNode *p = tr;
    st.push(p);

    while (!st.empty()) {
        while (p != NULL && p->lchild != NULL) {
            st.push(p->lchild);
            p = p->lchild;
        }

        p = st.top();
        cout << p->data << endl;
        st.pop();

        p = p->rchild;
        if (p != NULL) {
            st.push(p);
        }
    }
}

//后序递归遍历:左右根
void PostOrderTraverseRecursive(BiTNode *tr) {

    if (tr == NULL) {
        return;
    }

    PostOrderTraverseRecursive(tr->lchild);
    PostOrderTraverseRecursive(tr->rchild);
    cout << tr->data << endl;
}

//后序非递归遍历:左右根
void PostOrderTraverse(BiTNode *tr) {

    if (tr == NULL) {
        return;
    }

    stack<BiTNode *> st;
    st.push(tr);
    BiTNode *p = tr->lchild;

    while (!st.empty()) {
        while (p != NULL) {
            p->postOrderFlag = false;
            st.push(p);
            p = p->lchild;
        }

        p = st.top();
        if (p->rchild == NULL || p->postOrderFlag) { //2右孩子是4死循环
            cout << p->data << endl;
            st.pop();
            p = NULL;
        } else {
            p->postOrderFlag = true;
            p = p->rchild;
        }
    }
}

//层次遍历
void LevelOrderTraverse(BiTNode *tr) {
    if (tr == NULL) {
        return;
    }

    queue<BiTNode *> qu;
    BiTNode *p = tr;
    qu.push(p);

    while (!qu.empty()) {
        p = qu.front();
        cout << p->data << endl;
        if (p->lchild != NULL) {
            qu.push(p->lchild);
        }

        if (p->rchild != NULL) {
            qu.push(p->rchild);
        }
        qu.pop();
    }
}

//递归销毁二叉树
BiTNode *DestroyBiTree(BiTNode *tr) {
    if (tr == NULL) {
        return NULL;
    }

    DestroyBiTree(tr->lchild);
    DestroyBiTree(tr->rchild);

    free(tr);
    tr = NULL;

    return tr;
}

//递归求二叉树的高度
int GetBiTreeHeight(BiTNode *tr) {
    if (tr == NULL) {
        return 0;
    }

    if (tr->lchild == NULL && tr->rchild == NULL) {
        return 1;
    }

    return max(GetBiTreeHeight(tr->lchild), GetBiTreeHeight(tr->rchild)) + 1;
}

//递归求树的节点数
int GetBiTreeCount(BiTNode *tr) {
    if (tr == NULL) {
        return 0;
    }

    int lNum = GetBiTreeCount(tr->lchild);
    int rNum = GetBiTreeCount(tr->rchild);
    return lNum + rNum + 1;
}