二叉树：后序，递归和非递归，应用（求祖先问题）

1  声明

数据结构和功能函数如前一篇博客所述，如有疑问，详见博客地址：http://blog.csdn.net/tubin100/article/category/6142259

2 后序

a 递归

void PostOrder(BiTree T) {    if (T) {        PostOrder(T->lChild);        PostOrder(T->rChild);        visit(T);    }}

b 非递归

 i）由于是后序遍历，必须先访问左右，再访问根，只有通过设置栈保存之前访问过的节点，这样才能在访问完右子树之后回到根节点。

ii）这样，就有两种情况访问到根节点。一种是第一次访问，另一种是已经访问过子树后回到根。 为了区分两种情况，设置一个指针用于标识访问过的节点。

void PostOrder_2(BiTree T) {    if (!T) {        Error();        return;    }        std::stack<BiTNode*> st;    BiTNode *p = T;    BiTNode *flag = nullptr;    //标识被访问过的节点        while (p || !st.empty()) {        if (p) {            st.push(p);            p = p->lChild;        } else {            p = st.top();       //取当前栈顶            if (p->rChild && p->rChild != flag) {                p = p->rChild;            } else {                st.pop();                                visit(p);                                flag = p;                p = nullptr;  //经过循环条件后，直接再取栈顶            }        }    }}

3  应用

a 求给定某节点的所有祖先

i）思路分析：后序遍历中，访问到节点x时，当前栈中所有节点即为该节点的祖先。因此读取栈中的内容即可。

               但因为STL栈只提供top()接口，不方便顺序访问。故此处，用vector模拟栈的实现。

ii）关键分析：一旦找到节点之后，打印栈中所有元素，直接返回。

void Ancestor(BiTree T, std::vector<BiTNode*>& v, BTElemType e) {    if (!T) {        Error();        return;    }    v.clear();        BiTNode *p = T;    BiTNode *pFlag = nullptr;        while (T || !v.empty()) {        if (p) {            if (p->data == e) {                //找到e时，该vector中所有元素即为e的ancestor                for (auto iter = v.begin(); iter != v.end(); ++iter) {                    cout << (*iter)->data << " ";                }                return;            } else {                v.push_back(p); //模拟入栈                p = p->lChild;            }        } else {            p = *(v.end() - 1); //模拟取栈顶            if (p->rChild && p->rChild != pFlag) {                p = p->rChild;            } else {                v.pop_back();   //模拟出栈                pFlag = p;                p = nullptr;            }        }    }}

b 求给定两个节点的最近公共祖先

i）思路分析：

先得到一个节点x的后序遍历栈st1，把该栈拷贝到另一个栈中st2，作为该节点的后序遍历栈

然后继续遍历，直到找到另一个元素y，此时st1栈中元素即为y的后序遍历栈

最后，寻找两个栈中最后一个相同的元素，即为两个元素的最近公共祖先

ii）缺陷：

该方法的主要缺陷是：x必须出现在y左边。

代码如下：

//寻找最近公共祖先主程序

BTElemType CommonAncestor(BiTree T, BTElemType x, BTElemType y) {    std::vector<BiTNode*> st1, st2;        BiTNode *p = T;    BiTNode *pFlag = nullptr;        BTElemType result = '?'; //标识是否有公共祖先        while (p || !st1.empty()) {        if (p) {            if (p->data == x) {                //b把当前所有元素拷贝到st2中                st2 = st1;            }            if (p->data == y){                result = FindLastCommonElem(st1, st2, T);                break;            }            st1.push_back(p);            p = p->lChild;        } else {            p = *(st1.end() - 1);            if (p->rChild && p->rChild != pFlag) {                p = p->rChild;            } else {                st1.pop_back();                pFlag = p;                p = nullptr;            }        }    }        return result;  //调用者通过判断 result == '?'来得出是否存在公共组选}

//当找到x和y之后，查找两个栈中最后一个相同元素BTElemType FindLastCommonElem(std::vector<BiTNode*>& st1, std::vector<BiTNode*>& st2, BiTree T) {    if (st1.size() == 0 || st2.size() == 0) {   //x和y中至少有一个为根节点        return T->data;    }        BiTNode *pResult = nullptr;        //笔者起初想的用最简单的办法直接扫描两个vector，然后找出最后一个公共元素，但时间复杂度是O(n^2)，而此方法为O(n)        if (st1.size() < st2.size()) {        pResult = *(st1.end() - 1); //st1中最后一个元素即为公共元素    } else if (st1.size() > st2.size()){        pResult = *(st2.end() - 1); //st2中最后一个元素即为公共元素    } else {        auto iter1 = st1.begin();        auto iter2 = st2.begin();        for (; iter1 != st1.end(); ++iter1, ++iter2) {            if ((*iter1)->data != (*iter2)->data) {                break;            }        }        pResult = *(iter1 - 1);    }        return pResult->data;}

4 总结

1  后序遍历的非递归代码给我的启示：在适当的时候做标记，

2  一旦掌握了后序遍历非递归，那么其的应用可以根据模版，适当的修改，即可解决问题。