通過上一篇的部落格我們知道，可以利用棧來實現二叉樹的後序遍歷。其實這裡有一個性質，就是當使用非遞迴後序遍歷時，棧中的元素就是當前節點到根節點的路徑。利用這個規律，我們就可以求解最近公共最先問題了。

演算法

1. 找出兩個節點各自到根節點的路徑。這裡利用非遞迴後序遍歷二叉樹，既可以找到兩個節點到根節點的路徑。
2. 根據路徑找出最近的公共祖先。首先根節點肯定是他們的祖先，可以從跟節點開始查詢，直到最後一個相同的樹節點，就是他們的公共祖先了。

實現

///求兩個節點的最大公共祖先
void BiTree::ancestor(char A,char B){
    vector<BiNode *>
 
 pathA,pathB;
    ///非遞迴後序遍歷
    ///p表示當前樹節點指標，
    ///r表示最近訪問的樹節點指標
    BiNode *p,*r;
    r = NULL;
    p = root;
    stack<BiNode*> my_stack;
    int pathCnt=0;
    while(p!=NULL || !my_stack.empty()){
        if(p){
            ///一直走到樹的最左邊
            my_stack.push(p);
            p=p->lchild;
        }
        else
 
{
            p=my_stack.top();
            ///如果右子樹沒有遍歷，遍歷右子樹
            if(p->rchild!=NULL && p->rchild!=r){
                p=p->rchild;
                my_stack.push(p);
                ///注意這裡需要向左轉，因為如果不向左轉，
                ///將會遍歷右子樹節點兩邊
                p=p->lchild;

            }
            ///否則遍歷根節點
 

            else{
                p=my_stack.top();
                my_stack.pop();
                ///記錄A的路徑
                if(p->data==A){
                    cout<<"找到"<<A<<"的路徑："<<endl;
                    pathA.push_back(p);
                    while(!my_stack.empty()){
                        p=my_stack.top();
                        my_stack.pop();
                        pathA.push_back(p);
                    }
                    ///恢復my_stack
                    for(int i=pathA.size()-1;i>=0;i--){
                        cout<<pathA[i]->data<<' ';
                        my_stack.push(pathA[i]);
                        p=pathA[i];
                    }
                    p=my_stack.top();
                    my_stack.pop();
                    cout<<endl;
                    ///找到了一個節點的路徑
                    ++pathCnt;
                }
                ///記錄B的路徑
                if(p->data==B){
                    cout<<"找到"<<B<<"的路徑："<<endl;
                    pathB.push_back(p);
                    while(!my_stack.empty()){
                        p=my_stack.top();
                        my_stack.pop();
                        pathB.push_back(p);
                    }
                    ///恢復my_stack
                    for(int i=pathB.size()-1;i>=0;i--){
                        cout<<pathB[i]->data<<' ';
                        my_stack.push(pathB[i]);
                        p=pathB[i];
                    }
                    p=my_stack.top();
                    my_stack.pop();
                    cout<<endl;
                    ///找到了另一個節點的路徑
                    ++pathCnt;
                }
                ///如果找到了兩個節點的路徑就不遍歷了
                if(pathCnt==2)
                    break;
                ///更新最近遍歷的節點
                r=p;
                ///將遍歷後的節點設為NULL，進行下一個節點的遍歷
                p=NULL;
            }
        }
    }
    BiNode *common_node;
    int i,j;
    i=pathA.size()-1;
    j=pathB.size()-1;
    while(i>=0 && j>=0 && pathA[i]==pathB[j]){
        ///更新公共結點
        common_node = pathA[i];
        --i,--j;
    }
    cout<<"結點"<<A<<"和節點"<<B<<"的最近公共祖先是"<<common_node->data<<"。"<<endl;
}

測試

#include <iostream>
#include "BiTree.h"
using namespace std;

int main()
{
    BiTree a;
    string s;
    s="ABD##E#F##C##";
    a.createBiTree(s);
    a.ancestor('D','D');
    cout<<"--------------------"<<endl;
    a.ancestor('D','F');
    cout<<"--------------------"<<endl;
    a.ancestor('D','C');
    cout<<"--------------------"<<endl;
    return 0;
}