二叉樹兩個節點的公共節點

sunmenggmail發表於2012-04-16
二叉樹

轉自：http://blog.csdn.net/hhygcy/article/details/4660362


很流行的一個問題，常見於各種面試中，http://fayaa.com/tiku/view/16/ 這裡有一個很好的彙總.

找尋二叉樹中兩個節點的公共父節點中最近的那個節點

情況1. 節點只有left/right，沒有parent指標，root已知

情況2. root未知，但是每個節點都有parent指標

情況3. 二叉樹是個二叉查詢樹，且root和兩個節點的值(a, b)已知

雖然情況一是第一個情況，但是看上去比較複雜，我們放到最後來說，先從第二個情況開始說。

                                             10

                                          /       /
                                        6         14
                                      /  /       /　  /
                                   　4   8   12 　 16

                                   /  /

                                  3   5

畫一個二叉樹來做例子。如果我們要找3和8這兩個節點的公共父親節點，我們的做法是首先找到3到根節點的路勁，然後找到8到根節點的路徑。

                                             10

                                          //       /
                                        6         14
                                      /  /        /　  /
                                   　4   8   12 　 16

                                   /   /

                                  3   5

3的路徑用紅色表示，8的用綠色表示，可以看到， 這裡的問題實際上是另一個我們熟知的問題，有2個相交的單連結串列，找出它們的相交點！

只要把這個二叉樹的圖片倒過來看，或者把脖子倒過來看就知道了:)那個方法也是傳統的求出linkedList A的長度lengthA, linkedList B的長度LengthB。然後讓長的那個連結串列走過abs(lengthA-lengthB)步之後，齊頭並進，就能解決了。

[cpp] view plaincopy
  1. int getLength (bstNode* pNode)  
  2. {     
  3.     int length = 0;  
  4.     bstNode* pTemp = pNode;  
  5.     while (pTemp)  
  6.     {  
  7.         length ++ ;  
  8.         pTemp = pTemp->pParent;  
  9.     }  
  10.     return length;  
  11. }  
  12. bstNode* findLCACase2(bstNode* pNode1, bstNode* pNode2)  
  13. {  
  14.     int length1 = getLength(pNode1);  
  15.     int length2 = getLength(pNode2);  
  16.       
  17.     // skip the abs(length1-length2)  
  18.     bstNode* pIter1 = NULL;  
  19.     bstNode* pIter2 = NULL;  
  20.     int k=0;  
  21.     if (length1>=length2)  
  22.     {  
  23.         bstNode* pTemp = pNode1;  
  24.         while (k++<length1-length2)  
  25.         {  
  26.             pTemp = pTemp->pParent;   
  27.         }  
  28.         pIter1 = pTemp;  
  29.         pIter2 = pNode2;  
  30.     }  
  31.     else  
  32.     {  
  33.         bstNode* pTemp = pNode1;  
  34.         while (k++<length2-length1)  
  35.         {  
  36.             pTemp = pTemp->pParent;   
  37.         }  
  38.         pIter1 = pNode1;  
  39.         pIter2 = pTemp;  
  40.     }  
  41.       
  42.     while (pIter1&&pIter2&&pIter1!= pIter2)  
  43.     {  
  44.         pIter1 = pIter1->pParent;  
  45.         pIter2 = pIter2->pParent;  
  46.     }  
  47.     return pIter1;  
  48. }  

自己寫了個程式碼，總覺得有些拖沓冗餘，希望有緣人看到文章之後能幫我改寫的更和諧一些。

 

還是原來這個圖，情況三，如果是個二叉搜尋樹，而且root和a, b已知，我們這個case假設a,b=3,8。從知道根這個條件我們很自然聯想到遞迴(當然不遞迴也可以)地往下找。關鍵是收斂條件，什麼情況下可以判斷出當然檢查的這個節點是最近父親節點呢？其實從這個例子已經可以看出一些端倪了，如果當前訪問的節點比a,b來的都小，肯定不行。如果比a,b都大，也不行。那也就是說，這個節點只有在a<=node<=b的區間內才成立(我們假定a<b這裡)。這樣的問題，網上廣為流傳著類似的程式碼：

[cpp] view plaincopy
  1. bstNode* findLCACase3(bstNode* pNode, int value1, int value2)  
  2. {  
  3.     bstNode* pTemp = pNode;  
  4.     while (pTemp)  
  5.     {  
  6.         if (pTemp->data>value1 && pTemp->data>value2)  
  7.             pTemp = pTemp->pLeft;  
  8.         else if(pTemp->data<value1 && pTemp->data<value2)  
  9.             pTemp = pTemp->pRight;  
  10.         else  
  11.             return pTemp;  
  12.     }  
  13.     return NULL;  
  14. }  

 

好，前面的問題都解決了，我們再回過頭來看第一個情況，只有ROOT和left, right節點，沒有parent也不是排序樹，怎麼辦？網路上也流傳著很多所謂的LCA,RMQ演算法，我們不暇找個最合適的，尤其是在面試的時候，特定時間空間下你很難寫出一個邏輯非常複雜的東西(比如你會在面試的時候去實現一個Suffix Tree還是用動態規劃來求最長公共子串，哪怕效率不同，我也選擇動態規劃:))。所以這裡，碰到類似的問題的時候，我選擇簡單的記錄找到node1和node2的路徑，然後再把它們的路徑用類似的情況二來做分析，比如還是node1=3,node2=8這個case.我們肯定可以從根節點開始找到3這個節點，同時記錄下路徑3,4,6,10，類似的我們也可以找到8,6,10。我們把這樣的資訊儲存到兩個vector裡面，把長的vector開始的多餘節點3扔掉，從相同剩餘長度開始比較，4!=8, 6==6, coooool,我們找到了我們的答案。下面的程式碼完全按照這個思路寫成

[cpp] view plaincopy
  1. #include <vector>  
  2. bool nodePath (bstNode* pRoot, int value, std::vector<bstNode*>& path)  
  3. {  
  4.     if (pRoot==NULL) return false;  
  5.     if (pRoot->data!=value)  
  6.     {  
  7.         if (nodePath(pRoot->pLeft,value,path))  
  8.         {  
  9.             path.push_back(pRoot);  
  10.             return true;  
  11.         }  
  12.         else  
  13.         {  
  14.             if (nodePath(pRoot->pRight,value,path))  
  15.             {  
  16.                 path.push_back(pRoot);  
  17.                 return true;  
  18.             }  
  19.             else  
  20.                 return false;  
  21.         }  
  22.     }  
  23.     else  
  24.     {  
  25.         path.push_back(pRoot);  
  26.         return true;  
  27.     }  
  28. }  
  29. bstNode* findLCACase1(bstNode* pNode, int value1, int value2)  
  30. {  
  31.     std::vector<bstNode*> path1;  
  32.     std::vector<bstNode*> path2;  
  33.     bool find = false;  
  34.     find |= nodePath(pNode, value1, path1);  
  35.     find &= nodePath(pNode, value2, path2);  
  36.     bstNode* pReturn=NULL;  
  37.     if (find)  
  38.     {  
  39.         int minSize = path1.size()>path2.size()?path2.size():path1.size();  
  40.         int it1 = path1.size()-minSize;  
  41.         int it2 = path2.size()-minSize;  
  42.         for (;it1<path1.size(),it2<path2.size();it1++,it2++)  
  43.         {  
  44.             if (path1[it1]==path2[it2])  
  45.             {  
  46.                 pReturn = path1[it1];  
  47.                 break;  
  48.             }  
  49.         }  
  50.     }  
  51.     return pReturn;  
  52. }  

這段程式碼經歷了大概30分鐘的修改和debug，然後才逐漸穩定下來，真的很難想象如果是在面試的環境下，在紙筆之上會有如何的表現，可能真是隻有天知道了。

相關文章