2. 程式人生 > >二叉樹最近公共父節點（記錄根到某一節點路徑）

二叉樹最近公共父節點（記錄根到某一節點路徑）

阿新 • • 發佈：2019-01-06
 題目：二叉樹的結點定義如下：

    struct TreeNode

   {

              int m_nvalue;

             TreeNode* m_pLeft;

             TreeNode* m_pRight;

};

輸入二叉樹中的兩個結點，輸出這兩個結點在數中最低的共同父結點。

        分析：求數中兩個結點的最低共同結點是面試中經常出現的一個問題。這個問題至少有兩個變種。

        第一變種是二叉樹是一種特殊的二叉樹：查詢二叉樹。也就是樹是排序過的，位於左子樹上的結點都比父結點小，而位於右子樹的結點都比父結點大。我們只需要從根結點開始和兩個結點進行比較。如果當前結點的值比兩個結點都大，則最低的共同父結點一定在當前結點的左子樹中。如果當前結點的值比兩個結點都小，則最低的共同父結點一定在當前結點的右子樹中。

        第二個變種是樹不一定是二叉樹，每個結點都有一個指標指向它的父結點。於是我們可以從任何一個結點出發，得到一個到達樹根結點的單向連結串列。因此這個問題轉換為求兩個單向連結串列的第一個公共結點。

       現在我們回到這個問題本身。所謂共同的父結點，就是兩個結點都出現在這個結點的子樹中。因此我們可以定義一函式，來判斷一個結點的子樹中是不是包含了另外一個結點。這不是件很難的事，我們可以用遞迴的方法來實現：

[cpp] view plain copy print?
  1. /* 
  2. // If the tree with head pHead has a node pNode, return true.
     
  3. // Otherwise return false. 
  4. */
  5. bool HasNode(TreeNode* pHead, TreeNode* pNode)  
  6. {  
  7.     if(pHead == pNode)  
  8.         returntrue;  
  9.     bool has = false;  
  10.     if(pHead->m_pLeft != NULL)  
  11.         has = HasNode(pHead->m_pLeft, pNode);  
  12.     if(!has && pHead->m_pRight != NULL)  
  13.         has = HasNode(pHead->m_pRight, pNode);  
  14.     return has;  
  15. }  
/*
// If the tree with head pHead has a node pNode, return true.
// Otherwise return false.
*/
bool HasNode(TreeNode* pHead, TreeNode* pNode)
{
	if(pHead == pNode)
		return true;
	bool has = false;
	if(pHead->m_pLeft != NULL)
		has = HasNode(pHead->m_pLeft, pNode);
	if(!has && pHead->m_pRight != NULL)
		has = HasNode(pHead->m_pRight, pNode);
	return has;
}

       我們可以從根結點開始，判斷以當前結點為根的樹中左右子樹是不是包含我們要找的兩個結點。如果兩個結點都出現在它的左子樹中，那最低的共同父結點也出現在它的左子樹中。如果兩個結點都出現在它的右子樹中，那最低的共同父結點也出現在它的右子樹中。如果兩個結點一個出現在左子樹中，一個出現在右子樹中，那當前的結點就是最低的共同父結點。基於這個思路，我們可以寫出如下程式碼：

[cpp] view plain copy print?
  1. /* 
  2. // Find the last parent of pNode1 and pNode2 in a tree with head pHead 
  3. */
  4. TreeNode* LastCommonParent_1(TreeNode* pHead, TreeNode* pNode1, TreeNode* pNode2)  
  5. {  
  6.     if(pHead == NULL || pNode1 == NULL || pNode2 == NULL)  
  7.         return NULL;  
  8.     // check whether left child has pNode1 and pNode2
  9.     bool leftHasNode1 = false;  
  10.     bool leftHasNode2 = false;  
  11.     if(pHead->m_pLeft != NULL)  
  12.     {  
  13.         leftHasNode1 = HasNode(pHead->m_pLeft, pNode1);  
  14.         leftHasNode2 = HasNode(pHead->m_pLeft, pNode2);  
  15.     }   
  16.     if(leftHasNode1 && leftHasNode2)  
  17.     {  
  18.         if(pHead->m_pLeft == pNode1 || pHead->m_pLeft == pNode2)  
  19.             return pHead;  
  20.         return LastCommonParent_1(pHead->m_pLeft, pNode1, pNode2);  
  21.     }  
  22.     // check whether right child has pNode1 and pNode2
  23.     bool rightHasNode1 = false;  
  24.     bool rightHasNode2 = false;  
  25.     if(pHead->m_pRight != NULL)  
  26.     {  
  27.         if(!leftHasNode1)  
  28.             rightHasNode1 = HasNode(pHead->m_pRight, pNode1);  
  29.         if(!leftHasNode2)  
  30.             rightHasNode2 = HasNode(pHead->m_pRight, pNode2);  
  31.     }  
  32.     if(rightHasNode1 && rightHasNode2)  
  33.     {  
  34.         if(pHead->m_pRight == pNode1 || pHead->m_pRight == pNode2)  
  35.             return pHead;  
  36.         return LastCommonParent_1(pHead->m_pRight, pNode1, pNode2);  
  37.     }  
  38.     if((leftHasNode1 && rightHasNode2) || (leftHasNode2 && rightHasNode1))  
  39.         return pHead;   
  40.     return NULL;  
  41. }  
/*
// Find the last parent of pNode1 and pNode2 in a tree with head pHead
*/
TreeNode* LastCommonParent_1(TreeNode* pHead, TreeNode* pNode1, TreeNode* pNode2)
{
	if(pHead == NULL || pNode1 == NULL || pNode2 == NULL)
		return NULL;

	// check whether left child has pNode1 and pNode2
	bool leftHasNode1 = false;
	bool leftHasNode2 = false;
	if(pHead->m_pLeft != NULL)
	{
		leftHasNode1 = HasNode(pHead->m_pLeft, pNode1);
		leftHasNode2 = HasNode(pHead->m_pLeft, pNode2);
	} 

	if(leftHasNode1 && leftHasNode2)
	{
		if(pHead->m_pLeft == pNode1 || pHead->m_pLeft == pNode2)
			return pHead;
		return LastCommonParent_1(pHead->m_pLeft, pNode1, pNode2);
	}

	// check whether right child has pNode1 and pNode2
	bool rightHasNode1 = false;
	bool rightHasNode2 = false;
	if(pHead->m_pRight != NULL)
	{
		if(!leftHasNode1)
			rightHasNode1 = HasNode(pHead->m_pRight, pNode1);
		if(!leftHasNode2)
			rightHasNode2 = HasNode(pHead->m_pRight, pNode2);
	}

	if(rightHasNode1 && rightHasNode2)
	{
		if(pHead->m_pRight == pNode1 || pHead->m_pRight == pNode2)
			return pHead;
		return LastCommonParent_1(pHead->m_pRight, pNode1, pNode2);
	}

	if((leftHasNode1 && rightHasNode2) || (leftHasNode2 && rightHasNode1))
		return pHead; 

	return NULL;
}

         接著我們來分析一下這個方法的效率。函式HasNode的本質就是遍歷一棵樹，其時間複雜度是O(n)（n是樹中結點的數目）。由於我們根結點開始，要對每個結點呼叫函式HasNode。因此總的時間複雜度是O(n^2)。

        我們仔細分析上述程式碼，不難發現我們判斷以一個結點為根的樹是否含有某個結點時，需要遍歷樹的每個結點。接下來我們判斷左子結點或者右結點為根的樹中是否含有要找結點，仍然需要遍歷。第二次遍歷的操作其實在前面的第一次遍歷都做過了。由於存在重複的遍歷，本方法在時間效率上肯定不是最好的。

        前面我們提過如果結點中有一個指向父結點的指標，我們可以把問題轉化為求兩個連結串列的共同結點。現在我們可以想辦法得到這個連結串列。我們在這裡稍作變化即可：

[cpp] view plain copy print?
  1. /* 
  2. // Get the path form pHead and pNode in a tree with head pHead 
  3. */
  4. bool GetNodePath(TreeNode* pHead, TreeNode* pNode, std::list<TreeNode*>& path)  
  5. {  
  6.     if(pHead == pNode)  
  7.         returntrue;   
  8.     path.push_back(pHead);   
  9.     bool found = false;  
  10.     if(pHead->m_pLeft != NULL)  
  11.         found = GetNodePath(pHead->m_pLeft, pNode, path);  
  12.     if(!found && pHead->m_pRight)  
  13.         found = GetNodePath(pHead->m_pRight, pNode, path);  
  14.     if(!found)  
  15.         path.pop_back();  
  16.     return found;  
  17. }  
/*
// Get the path form pHead and pNode in a tree with head pHead
*/
bool GetNodePath(TreeNode* pHead, TreeNode* pNode, std::list<TreeNode*>& path)
{
	if(pHead == pNode)
		return true; 

	path.push_back(pHead); 

	bool found = false;
	if(pHead->m_pLeft != NULL)
		found = GetNodePath(pHead->m_pLeft, pNode, path);
	if(!found && pHead->m_pRight)
		found = GetNodePath(pHead->m_pRight, pNode, path);
	if(!found)
		path.pop_back();
	return found;
}

      由於這個路徑是從跟結點開始的。最低的共同父結點就是路徑中的最後一個共同結點：

[cpp] view plain copy print?
  1. /* 
  2. // Get the last common Node in two lists: path1 and path2 
  3. */
  4. TreeNode* LastCommonNode  
  5. (  
  6.  const std::list<TreeNode*>& path1,   
  7.  const std::list<TreeNode*>& path2  
  8.  )  
  9. {  
  10.     std::list<TreeNode*>::const_iterator iterator1 = path1.begin();  
  11.     std::list<TreeNode*>::const_iterator iterator2 = path2.begin();     
  12.     TreeNode* pLast = NULL;  
  13.     while(iterator1 != path1.end() && iterator2 != path2.end())  
  14.     {  
  15.         if(*iterator1 == *iterator2)  
  16.             pLast = *iterator1;  
  17.         iterator1++;  
  18.         iterator2++;  
  19.     }  
  20.     return pLast;  
  21. }  
/*
// Get the last common Node in two lists: path1 and path2
*/
TreeNode* LastCommonNode
(
 const std::list<TreeNode*>& path1, 
 const std::list<TreeNode*>& path2
 )
{
	std::list<TreeNode*>::const_iterator iterator1 = path1.begin();
	std::list<TreeNode*>::const_iterator iterator2 = path2.begin();   

	TreeNode* pLast = NULL;
	while(iterator1 != path1.end() && iterator2 != path2.end())
	{
		if(*iterator1 == *iterator2)
			pLast = *iterator1;

		iterator1++;
		iterator2++;
	}
	return pLast;
}

        有了前面兩個子函式之後，求兩個結點的最低共同父結點就很容易了。我們先求出從根結點出發到兩個結點的兩條路徑，再求出兩條路徑的最後一個共同結點。程式碼如下：

[cpp] view plain copy print?
  1. /* 
  2. // Find the last parent of pNode1 and pNode2 in a tree with head pHead 
  3. */
  4. TreeNode* LastCommonParent_2(TreeNode* pHead, TreeNode* pNode1, TreeNode* pNode2)  
  5. {  
  6.     if(pHead == NULL || pNode1 == NULL || pNode2 == NULL)  
  7.         return NULL;  
  8.     std::list<TreeNode*> path1;  
  9.     GetNodePath(pHead, pNode1, path1);  
  10.     std::list<TreeNode*> path2;  
  11.     GetNodePath(pHead, pNode2, path2);  
  12.     return LastCommonNode(path1, path2);  
  13. }  
/*
// Find the last parent of pNode1 and pNode2 in a tree with head pHead
*/
TreeNode* LastCommonParent_2(TreeNode* pHead, TreeNode* pNode1, TreeNode* pNode2)
{
	if(pHead == NULL || pNode1 == NULL || pNode2 == NULL)
		return NULL;

	std::list<TreeNode*> path1;
	GetNodePath(pHead, pNode1, path1);

	std::list<TreeNode*> path2;
	GetNodePath(pHead, pNode2, path2);

	return LastCommonNode(path1, path2);
}

        這種思路的時間複雜度是O(n)，時間效率要比第一種方法好很多。但同時我們也要注意到，這種思路需要兩個連結串列來儲存路徑，空間效率比不上第一個方法。


相關推薦

二叉樹最近公共父節點（記錄根到某一節點路徑）

 題目：二叉樹的結點定義如下：     struct TreeNode    {               int m_nvalue;              TreeNode* m_pLeft;              TreeNode* m_pRight; };

二叉樹---最近公共父節點(LCA)

點子 clas urn com 祖先 ces 代碼 col 深度 題目： 給定一棵二叉樹，找到兩個節點的最近公共父節點(LCA)。 最近公共祖先是兩個節點的公共的祖先節點且具有最大深度。 4 / 3 7 / 5 6 LCA

二叉樹最近公共父節點

在二叉樹中找最近公共父節點。分為兩種情況，一種是有父指標，一種沒有父指標。 1、有父指標 這種情況比較簡單，計算兩個結點的深度，再把深度大的向上移，移到同一深度。在同時向上移動，直到兩個結點相同，這樣

YTU_3309: Lorenzo Von Matterhorn（完全二叉樹 最近公共祖先）

3309: Lorenzo Von Matterhorn 時間限制: 1 Sec  記憶體限制: 128 MB 提交: 6  解決: 6 [提交][狀態][討論版][命題人:acm4302] 題目描述 Barney住在紐約。紐約市有無限數量的路口，路口為從1開始編號的正

二叉樹最近公共祖先

ret highlight 筆試 代碼 light brush 二叉 init blog 給定一棵二叉樹，找到兩個節點的最近公共父節點(LCA)。最近公共祖先是兩個節點的公共的祖先節點且具有最大深度。 樣例：對於下面這棵二叉樹 4 / \3 7 / \ 5

二叉樹的公共父結點

題目描述：       1        / \     2   3  &n

多叉樹最近公共祖先問題（LCA）

任務：設計一個演算法，對於給定的樹中兩結點，返回它們的最近公共祖先 輸入：第1行有一個正整數n，表示給定的樹有n個結點。結點編號為1,2,3,...,n，編號為1的頂點是樹根。接下來n行中，第i+1行描述了第i個結點的兒子情況。每行的第一個正整數k表示該結點有k個兒子，其後

二叉樹的遍歷方式（遞歸、非遞歸）

前序遍歷 遍歷 層序 blog col node pre nbsp 二叉樹的遍歷 二叉樹的前序、中序、後序遍歷方式，遞歸與非遞歸。（層序遍歷的方式已經在之前的博客中寫過） 遞歸方式比較簡單。 前序遍歷： void preorder(TreeNode* root){

LeetCode 114. 二叉樹展開為鏈表（Flatten Binary Tree to Linked List）

tree binary ont 基本思想 oot public ike 返回 上一個 題目描述 給定一個二叉樹，原地將它展開為鏈表。 例如，給定二叉樹 1 / 2 5 / \ 3 4 6 將其展開為： 1 2 3

二叉樹的遍歷方式（遞迴、非遞迴）——Java實現

二叉樹作為一種常用的資料結構，也是面試經常被問到的知識點，瞭解二叉樹的結構和性質也是很有必要的，對於眾多的樹結構，二叉樹只是入門的一種，先把二叉樹理解通透，再深入學習時，會更簡單一些。 二叉樹的性質： (1) 在非空二叉樹中，第i層的結點總數不超過 , i>=1；

二叉樹後序遍歷（遞迴與非遞迴）演算法及C語言實現

二叉樹後序遍歷的實現思想是：從根節點出發，依次遍歷各節點的左右子樹，直到當前節點左右子樹遍歷完成後，才訪問該節點元素。 圖 1 二叉樹   如圖 1 中，對此二叉樹進行後序遍歷的操作過程為： 從根節點 1 開始，遍歷該節點的左子樹（以節點 2 為根節點）； 遍歷節點 2 的左子樹（以節點 4 為根

二叉樹中序遍歷（遞迴和非遞迴）演算法及C語言實現

二叉樹中序遍歷的實現思想是： 訪問當前節點的左子樹； 訪問根節點； 訪問當前節點的右子樹； 圖 1 二叉樹   以圖  1 為例，採用中序遍歷的思想遍歷該二叉樹的過程為： 訪問該二叉樹的根節點，找到 1； 遍歷節點 1 的左子樹，找到節點 2； 遍歷節點 2 的左子樹，找到節點 4；

二叉樹先序遍歷（遞迴與非遞迴）及C語言實現

二叉樹先序遍歷的實現思想是： 訪問根節點； 訪問當前節點的左子樹； 若當前節點無左子樹，則訪問當前節點的右子樹； 圖 1 二叉樹   以圖  1 為例，採用先序遍歷的思想遍歷該二叉樹的過程為： 訪問該二叉樹的根節點，找到 1； 訪問節點 1 的左子樹，找到節點 2； 訪問節點 2 的左子

二叉樹深度優先遍歷（遞迴、非遞迴）、廣度優先遍歷、構建二叉樹

public class BinaryTree { static class TreeNode{ int value; TreeNode left; TreeNode right; public Tree

二叉樹的遍歷演算法（遞迴與非遞迴）

        二叉樹的常用遍歷演算法有前序，中序，後序三種遍歷方法，可用遞迴及非遞迴方法實現，程式碼如下： public class BSTTraversal { public static class Node{ private int value; pri

二叉樹基礎-二叉樹類模板的實現（資料結構基礎 第5周）

這裡參考了課本配套的程式簡單實現了二叉樹類模板，主要包含了二叉樹的建立和各種遍歷方法。 對於二叉樹的建立，這裡使用的是前序遍歷的方法建立的二叉樹，具體如下： 這裡我使用的下圖中的二叉樹作為測試案例： 具體不說了，詳見程式碼吧。 原始碼 //t

N個節點的二叉樹有多少種形態（卡特蘭數）

面試 誤區 樹的定義 節點 類型 基礎 更多 大於等於 證明 這是一道阿裏的面試題。其實算不上新鮮，但是我之前沒關註過，如今碰到了，就順便探討下這個問題吧：） 拿到這個題，首先想到的是直接寫出表達式肯定不行，所以有必要從遞推入手。由特殊到一般，歸納法麽~而且二叉樹離不開遞推

二叉樹系列——二叉樹的最大距離（即相距最遠的兩個葉子節點，程式設計之美，百度面試題）

來自於程式設計之美3.8。 題目：如果我們把二叉樹看做圖，父子節點之間的連線看成是雙向的，我們姑且定義“距離”為兩個節點之間邊的個數。寫一個程式求一棵二叉樹中相距最遠的兩個節點之間的距離。 如下圖所

二叉樹建立、遍歷（前序，中序，後序），求葉節點個數，求節點個數

二叉樹是筆試面試中考試最頻繁的資料結構之一，主要包括，程式建立一個二叉樹，三種次序遍歷二叉樹，返回葉子節點的數目，求二叉樹節點的總數等。建立一個二叉樹節點的資料結構 typedef struct Node {int data;struct Node *left,*right

【樹】二叉樹遍歷算法（深度優先、廣度優先遍歷，前序、中序、後序、層次）及Java實現

order new link left 算法 很多 == 都是 off 二叉樹是一種非常重要的數據結構，很多其它數據結構都是基於二叉樹的基礎演變而來的。對於二叉樹，有深度遍歷和廣度遍歷，深度遍歷有前序、中序以及後序三種遍歷方法，廣度遍歷即我們平常所說的層次遍歷。因為樹的定義