五 树和二叉树

二叉树的定义

typedef struct node {
    char data;
    struct node * lchild;
    struct node * rchild;
} BTNode;

void InitBT(BTNode * &b) {
    b = (BTNode *) malloc(sizeof(BTNode));
    b->lchild = NULL;
    b->rchild = NULL;
}

二叉树的递归遍历

前序遍历

void PreOrder(BTNode * b) {
    if(b) {
        cout << b->data << " ";
        PreOrder(b->lchild);
        PreOrder(b->rchild);
    }
}

中序遍历

void InOrder(BTNode * b) {
    if(b) {
        InOrder(b->lchild);
        cout << b->data << " ";
        InOrder(b->rchild);
    }
}

后序遍历

void PostOrder(BTNode * b) {
    if(b) {
        PostOrder(b->lchild);
        PostOrder(b->rchild);
        cout << b->data << " ";
    }
}

二叉树的非递归遍历

层次遍历

void LevelOrder(BTNode *b) {
    queue< BTNode* > q;
    q.push(b);
    while(!q.empty()) {
        BTNode * now = q.front();
        q.pop();
        cout << now->data << " ";
        if(now->lchild)
            q.push(now->lchild);
        if(now->rchild)
            q.push(now->rchild);
    }
}

非递归先序遍历2种写法

void PreOrder1(BTNode * b) {
    BTNode * p;
    stack<BTNode *> st;
    if(b) {
        st.push(b);
        while(!st.empty()) {
            p = st.top();
            st.pop();
            cout << (p->data) << " ";
            if(p->rchild)
                st.push(p->rchild);
            if(p->lchild)
                st.push(p->lchild);
        }
        cout << endl;
    }
}

void PreOrder2(BTNode * b) {
    BTNode * p = b;
    stack<BTNode *> st;
    while(!st.empty() || p) {
        while(p) {
            cout << p->data << " ";
            st.push(p);
            p = p->lchild;
        }
        if(!st.empty()) {
            p = st.top();
            st.pop();
            p = p->rchild;
        }
    }
    cout << endl;
}

非递归中序遍历

void InOrder1(BTNode * b) {
    BTNode *p = b;
    stack<BTNode *> st;
    while(!st.empty() || p) {
        while(p) {
            st.push(p);
            p = p->lchild;
        }
        if(!st.empty()) {
            p = st.top();
            st.pop();
            cout << p->data << " ";
            p = p->rchild;
        }
    }
    cout << endl;
}

比较前序（2）和中序，发现两者区别只是入栈时输出还是出栈时输出

非递归后序遍历

void PostOrder1(BTNode *b) {
    BTNode *p = b, *r = NULL;
    stack<BTNode *> st;
    while(p || !st.empty()) {
        if(p) {
            st.push(p);
            p = p->lchild; //一边入栈一边往左
        } else { //最左边
            p = st.top(); //读取栈顶到p
            if(p->rchild && p->rchild != r) { //如果p又右子树，且没有被访问，则后序遍历右子树
                st.push(p->rchild); //右子树入栈
                p = p->rchild->lchild; //以相同的方式遍历右子树（往最左边跑）
            } else { //否则可以访问p了（因为p的右子树为空或者被访问了，当然左子树也被访问了）
                st.pop(); //p出栈
                cout << p->data << " ";
                r = p; //记录最近被访问的结点（如果p是它父亲的右结点，就代表下次可以访问p的父亲了）
                p = NULL; //重置p结点
            }
        }
    }
    cout << endl;
}