2. 程式人生 > >【資料結構】二叉樹中任意兩節點的最近公共祖先節點

【資料結構】二叉樹中任意兩節點的最近公共祖先節點

阿新 • • 發佈：2019-01-01

問題要求：任意給出二叉樹中的兩個節點，求他們的最近祖先

分三種情況：

1、該二叉樹是搜尋二叉樹

如果兩個節點的值都大於根節點，則遍歷右子樹查詢一個處於兩節點之間的值為最近祖先，如果兩個節點的值都小於根節點，則遍歷左子樹查詢一個兩節點之間的值為最近祖先

插入程式碼

Node* SearchNearAncestor(Node* root,Node* node1,Node*node2)
	{
		if (root==NULL||
			node1==NULL||
			node2==NULL)
		{
			return NULL;
		}
		if(node1==node2||node1->_parent!=NULL)
		{
			return node1;
		}
		Node* cur=root;
		while (cur)
		{
			if(cur->_key>node1->_key&&
				cur->_key>node2->_key)
			{
              cur=cur->_left;
			}
			else if(cur->_key<node1->_key&&
				cur->_key<node2->_key)
			{
				cur=cur->_right;
			}
			else 
			{
				if(node1->_parent==node2)
					return node2->_parent;
				else if(node2->_parent==node1)
					return node1->_parent;
				else
				return cur;
			}
		}

		return NULL;
	}
2、該二叉樹為普通二叉樹，但其有父節點，這時候，將node1的父節點和node2的parent->parent.......一直比較下去，直到二者相同，如果一直不同，則將node1再往上走，繼續上步迴圈

查詢程式碼為

Node* NearAncetor(Node* root,Node* node1,Node* node2)
	{
		if(node1==root||node2==root)
		{
			return root;
		}
		Node* tmp;
		while (node1!=NULL)
		{
			node1=node1->_parent;
			tmp=node2;
			while (tmp!=NULL)
			{
				if(node1==tmp->_parent)
					return node1;

				tmp=tmp->_parent;
			}
		}
		return NULL ;
	}

3、該二叉樹為普通二叉樹，他也沒有父節點，這時候要分別遞迴左右子樹，如果一個節點出現在左子樹，另一個出現在右子樹，則返回根節點，如果兩個都出現在左，則最近祖先在子樹，如果兩個都出現在右，則最近祖先在右子樹上

程式碼如下

Node* NearAncetor(Node* root,Node* node1,Node* node2)
	{
		if (root==NULL||
			node1==NULL||
			node2==NULL)
		{
			return NULL;
		}
		if(node1==root||node2==root)
		{
			return root;
		}
		Node* left=NearAncetor(root->_left,node1,node2);
		Node* right=NearAncetor(root->_right,node1,node2);
		if(left&&right)
			return root;
		if(left==NULL)
			return right;
		else
			return left;
	}

二叉搜尋樹全部程式碼 
#include<iostream>
using namespace std;
template<class K>
struct SearchTreeNode 
{
	typedef SearchTreeNode<K> Node;
	Node* _left;
	Node* _right;
	Node* _parent;
	K _key;
	SearchTreeNode(const K& key)
		:_left(NULL)
		,_right(NULL)
		,_parent(NULL)
		,_key(key)
	{}
};
template<class K>
class SearchTree
{
	typedef SearchTreeNode<K> Node;
public:
	SearchTree()
	:_root(NULL)
	{}
	~SearchTree()
	{
		delete _root;
	}
	SearchTree(const SearchTree<K>& t)  
	{  
		_root=t._root;  
	}  
	Node* GetRoot()
	{
		return _root;
	}
	bool Find(const K& key)
	{
		if(_root==NULL)
			return false;
		Node* cur=_root;
		while (cur)
		{
			if(cur->_key>key)
				cur=cur->_left;
			else if(cur->_key<key)
				cur=cur->_right;
			else 
				return true;
		}
	}
	bool Insert(const K&key)
	{
		_Insert(_root,key);
		return true;
	}
	void Inorder()
	{
		_Inorder(_root);
		cout<<endl;
	}
	Node* SearchNearAncestor(Node* root,Node* node1,Node*node2)
	{
		if (root==NULL||
			node1==NULL||
			node2==NULL)
		{
			return NULL;
		}
		if(node1==node2||node1->_parent!=NULL)
		{
			return node1;
		}
		Node* cur=root;
		while (cur)
		{
			if(cur->_key>node1->_key&&
				cur->_key>node2->_key)
			{
              cur=cur->_left;
			}
			else if(cur->_key<node1->_key&&
				cur->_key<node2->_key)
			{
				cur=cur->_right;
			}
			else 
			{
				if(node1->_parent==node2)
					return node2->_parent;
				else if(node2->_parent==node1)
					return node1->_parent;
				else
				return cur;
			}
		}

		return NULL;
	}
protected:
	
	bool _Insert(Node*& root, const K& key)
	{
		if(root==NULL)
		{
		  root=new Node(key);
		  return true;
		}
		if(root->_key>key)
		{
			return _Insert(root->_left,key);
		}
		else if(root->_key<key)
		{
			return _Insert(root->_right,key);
		}
		else
			return false;
	}
	void _Inorder(Node* root)
	{
		Node* cur=root;
		if(cur==NULL)
			return;
		_Inorder(cur->_left);
		cout<<cur->_key<<" ";
		_Inorder(cur->_right);
	}
protected:
	Node* _root;
};
//void testSearch()
//{
//	int arr[]={3,4,1,5,2,6,8,7,9};
//	SearchTree<int> t;
//	
//	
//	for(int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
//	{
//		t.Insert(arr[i]);
//	}
//	t.Inorder();
//  
//}
void test()
{
	int arr[]={5,3,4,1,7,8,2,6,0,9};
	SearchTree<int> t1;
	for(int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		t1.Insert(arr[i]);
	}
	t1.Inorder();
	SearchTreeNode<int>* root=t1.GetRoot();
	SearchTreeNode<int>* node1=root->_left->_right;
	SearchTreeNode<int>* node2=root->_right->_left;
	SearchTreeNode<int>* ancetor=t1.SearchNearAncestor(root,node1,node2);
	cout<<node1->_key<<"和"<<node2->_key<<"的最近祖先是"<<ancetor->_key<<endl;
	SearchTreeNode<int>* node3=root->_right->_right->_right;
	SearchTreeNode<int>* node4=root->_right->_left;
	SearchTreeNode<int>* ancetor2=t1.SearchNearAncestor(root,node3,node4);
	cout<<node3->_key<<"和"<<node4->_key<<"的最近祖先是"<<ancetor2->_key<<endl;
	cout<<endl;
}

這裡查詢4，6的最近祖先和9，6的最近祖先

結果

普通二叉樹有父節點的全部程式碼

#include <iostream>
using namespace std;
struct TreeNode
{
	TreeNode* _left;
	TreeNode* _right;
	TreeNode* _parent;
	int _key;
	TreeNode(const int& key)
		:_left(NULL)
		,_right(NULL)
		,_parent(NULL)
		,_key(key)
	{}
};
class BinrayTree
{
	typedef TreeNode Node;
public:
    BinrayTree()
		:_root(NULL)
	{}
	~BinrayTree()
	{
		delete _root;
	}
	Node* GetRoot()
	{
		return _root;
	}
	bool Insert2(const int& key)
	{
		_Insert(_root,key);
		return true;
	}
	void Inorder2()
	{
		_Inorder(_root);
		cout<<endl;
	}
	Node* NearAncetor(Node* root,Node* node1,Node* node2)
	{
		if(node1==root||node2==root)
		{
			return root;
		}
		Node* tmp;
		while (node1!=NULL)
		{
			node1=node1->_parent;
			tmp=node2;
			while (tmp!=NULL)
			{
				if(node1==tmp->_parent)
					return node1;

				tmp=tmp->_parent;
			}
		}
		return NULL ;
	}
protected:
	bool _Insert(Node*& root,const int& key)
	{
		Node* node=new Node(key);
		node->_key=key;
		node->_left=node->_right=node->_parent=NULL;
		if(root==NULL)
		{
			root=node;
			return true;
		}
		if(root->_left == NULL && root->_key > key)
		{
			node->_parent=root;
			root->_left=node;
			return true;
		}
		if(root->_right == NULL && root->_key < key)
		{
			node->_parent=root;
			root->_right=node;
			return true;
		}
		if(root->_key > key)
			_Insert(root->_left,key);
		else if(root->_key < key)
			_Insert(root->_right,key);
		else
			return true;
	}
	void  _Inorder(Node* root)
	{
		Node* cur=root;
		if(cur==NULL)
			return;
		_Inorder(cur->_left);
		cout<<cur->_key<<" ";
		_Inorder(cur->_right);
	}
	Node* _root;
};
void test2()
{
	int arr[]={5,3,4,1,7,8,2,6,0,9};
	BinrayTree t1;
	for(int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		t1.Insert2(arr[i]);
	}
	t1.Inorder2();
	TreeNode* root=t1.GetRoot();
	TreeNode* node1=root->_left->_left;
	TreeNode* node2=root->_right->_right;
	cout<<node1->_key<<"和"<<node2->_key<<"的最近祖先是";
	TreeNode* ancetor=t1.NearAncetor(root,node1,node2);
	if(ancetor)
	cout<<ancetor->_key<<endl;
	cout<<endl;
}


這裡測試1，8的最近祖先

普通二叉樹且無父節點全部程式碼

#include <iostream>
using namespace std;
struct NoParentTreeNode
{
	NoParentTreeNode* _left;
	NoParentTreeNode* _right;
	int _key;
	NoParentTreeNode(const int& key)
		:_left(NULL)
		,_right(NULL)
		,_key(key)
	{}
};
class NoParentBinrayTree
{
	typedef NoParentTreeNode Node;
public:
	NoParentBinrayTree()
		:_root(NULL)
	{}
	~NoParentBinrayTree()
	{
		delete _root;
	}
	Node* GetRoot()
	{
		return _root;
	}
	bool Insert2(const int& key)
	{
		_Insert(_root,key);
		return true;
	}
	void Inorder2()
	{
		_Inorder(_root);
		cout<<endl;
	}
	Node* NearAncetor(Node* root,Node* node1,Node* node2)
	{
		if (root==NULL||
			node1==NULL||
			node2==NULL)
		{
			return NULL;
		}
		if(node1==root||node2==root)
		{
			return root;
		}
		Node* left=NearAncetor(root->_left,node1,node2);
		Node* right=NearAncetor(root->_right,node1,node2);
		if(left&&right)
			return root;
		if(left==NULL)
			return right;
		else
			return left;
	}
protected:
	bool _Insert(Node*& root,const int& key)
	{
		if(root==NULL)
		{
			root=new Node(key);
			return true;
		}
		if(key>root->_key)
		{
			return  _Insert(root->_right,key);
		}
		else if(key<root->_key)
		{
			return  _Insert(root->_left,key);
		}
		else 
			return false;
	}
	void  _Inorder(Node* root)
	{
		Node* cur=root;
		if(cur==NULL)
			return;
		_Inorder(cur->_left);
		cout<<cur->_key<<" ";
		_Inorder(cur->_right);
	}
	Node* _root;
};
void test3()
{
	int arr[]={5,3,4,1,7,8,2,6,0,9};
	NoParentBinrayTree t1;
	for(int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		t1.Insert2(arr[i]);
	}
	t1.Inorder2();
	NoParentTreeNode* root=t1.GetRoot();
	NoParentTreeNode* node1=root->_left->_left;
	NoParentTreeNode* node2=root->_right->_right->_right;
	NoParentTreeNode* ancetor=t1.NearAncetor(root,node1,node2);
	cout<<node1->_key<<"和"<<node2->_key<<"的最近祖先是"<<ancetor->_key<<endl;
	cout<<endl;
}

這裡測試1，9的最近祖先


測試程式碼

#include "SearchTree.h"
#include "HaveParentUnsearchTree.h"
#include "NoParentSearchTree.h"
#include <cstdlib>
int main()
{
	test();
	test2();
	test3();
	system("pause");
	return 0;
}


相關推薦

【資料結構】二叉樹中任意兩節點的最近公共祖先節點

問題要求：任意給出二叉樹中的兩個節點，求他們的最近祖先 分三種情況： 1、該二叉樹是搜尋二叉樹 如果兩個節點的值都大於根節點，則遍歷右子樹查詢一個處於兩節點之間的值為最近祖先，如果兩個節點的值都小於根節點，則遍歷左子樹查詢一個兩節點之間的值為最近祖先 插入程式碼 Node*

【資料結構】二叉樹的前中後遍歷與層次遍歷(遞迴與非遞迴)

水一波作業 #include <iostream> #include <cstring> //#pragma GCC optimize(2) #include<time.h> #include <map> #include &

【資料結構】二叉樹的鏈式儲存結構（通過前序序列和中序序列構造二叉樹）

說明：需要分別輸入要二叉樹的前序序列和中序序列才能構建二叉樹。如果構建失敗，程式會報錯。 比如我們給定一個二叉樹，容易知道 前序序列為：GDAFEMHZ 中序序列為：ADEFGHMZ 程式執行結果： 原始碼 #include<stdio.h> #

【資料結構】二叉樹的相關操作（待更）

#include "stdio.h" #include "stdlib.h" typedef struct node { char data; struct node *rchild,*lchild; }bintnode; typedef bintnode *bintree;//指向該結構體

【資料結構】二叉樹的建立和遍歷（非遞迴）

該程式使用的是遞迴地建立方法，以及非遞迴的遍歷演算法 執行環境：Dev-C++ #include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *lchild

【資料結構】二叉樹的建立與遍歷（遞迴）

該程式全是使用遞迴的操作 執行環境是：Dev-C++ #include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *lchild,*rchild; }bi

【資料結構】二叉樹的應用

1、分別採用遞迴和非遞迴的方式編寫兩個函式，求一棵給定二叉樹中葉子節點的個數 2、返回一棵給定二叉樹在中序遍歷下的最後一個結點 3、假設二叉樹採用鏈式方式儲存，root為其根節點，p和q分別指向二叉樹中任意兩個結點，編寫一個函式，返回p和q最近的共同祖先。  #includ

【資料結構】二叉樹基本操作

文章目錄 BinaryTree.h BinaryTree.c Test.c 棧和佇列的相關函式: 棧：https://blog.csdn.net/weixin_41892460/article/details/82

【資料結構】二叉樹一些基本演算法

二叉樹中搜索某個元素的演算法。 /** * 查詢二叉樹中元素 * @param root * @param data * @return */ Boolean FinadIn

【資料結構】二叉樹介面的實現(用c語言實現）

二叉樹 概念 一棵二叉樹是結點的一個有限集合，該集合或者為空，或者是由一個根節點加上兩棵別稱為左子樹和右子樹的二又樹組成。 二叉樹的特點: 1.每個結點最多有兩棵子樹，即二叉樹不存在度大於2的結點。2.二又樹的子樹有左右之分，其子樹的次序不能顛倒   特殊的二

【資料結構】二叉樹的構建及遍歷（遞迴演算法）

題目描述： 編一個程式，讀入使用者輸入的一串先序遍歷字串，根據此字串建立一個二叉樹（以指標方式儲存）。 例如如下的先序遍歷字串： ABC##DE#G##F### 其中“#”表示的是空格，空格字元代表空樹。建立起此二叉樹以後，再對二叉樹進行中序遍歷，輸出遍歷結果。 具體程式

【資料結構】二叉樹的遍歷及應用

前言       在二叉樹的應用中，常常要求在樹中查詢某些結點，或者對樹中的結點統一進行某種處理。因此，就提到了二叉樹的遍歷問題，對於線性結構來說，遍歷是一個很容易解決的問題，而二叉樹偏偏是一種非線性的結構，因此需要尋找一種規律。        二叉樹由三個基本單

【資料結構】二叉樹的實現

上篇部落格中，我們詳細說明了樹和二叉樹的資料結構及其特徵，本次，我們用C++來實現一下二叉樹 定義二叉樹節點結構 二叉樹需要定義指向左孩子和右孩子節點的指標，還有儲存的資料；我們在這把它的建構函式也寫出來 //定義一個二叉樹節點 template<typename

【資料結構】二叉樹的遍歷

二叉樹的遍歷大致可分為先序遍歷、中序遍歷、後序遍歷和層次遍歷四種。具體的實現原理都比較簡單，這裡不再描述，現在給出具體的遍歷演算法。本文給出了二叉樹遍歷的遞迴演算法和非遞迴演算法，這樣有助於對照了解。 二叉樹的結構體  typedef stru

【資料結構】二叉樹演算法題思路

首先需要做到掌握三種常規遍歷（前、中、後）以及按層遍歷，幾乎所有的演算法題都逃不開這三種方法。 其次，做二叉樹題目，很多情況都可以使用遞迴的方法來做，要經常想這個。 舉例： 1. 二叉樹映象問題 2. 二叉樹找子樹問題

【資料結構】二叉樹的順序儲存

原理 對於具有n個節點的完全二叉樹，如果按照從上至下和從左至右的順序對所有節點序號從0開始順序編號，則對於序號為 i(0<=i < n)的節點有： 1)如果i〉0，則序號為i節點的雙親節點的序號為(i-1)/2(/為整除)；如果i=0，則序

【資料結構】二叉樹（順序儲存、鏈式儲存）的JAVA程式碼實現

二叉樹是一種非線性的資料結構。它是由n個有限元素的集合，該集合或者為空、或者由一個稱為根(root)的元素及兩顆不相交的、被分別稱為左子樹、右子樹的二叉樹組成。當集合為空時，稱該二叉樹為空二叉樹。在二叉樹中，一個元素也可以稱做一個結點。二叉樹是有序的，即若將其左右兩個子樹顛倒

【資料結構】---------二叉樹面試題（具體的所有實現）

實現二叉樹的相關的操作： 先序遍歷樹（遞迴） 中序遍歷樹（遞迴） 後序遍歷樹（遞迴） 層序遍歷樹 建立一棵樹 樹的銷燬 樹的拷貝 二叉樹中節點的個數 二叉樹葉子節點的個數 二叉樹第K層節點的個數 樹的高度 在二叉樹中查詢節點 找當前節點的左子樹

【資料結構】二叉樹面試題總結

為了對二叉樹的知識進行鞏固，今天我們來解析5道二叉樹的經典面試題。 這五道面試題如下： 求二叉樹中最遠兩個結點的距離； 判斷一棵樹是否是完全二叉樹； 由前序和中序遍歷序列重建二叉樹 （前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6

【演算法與資料結構】二叉樹查詢

目錄 概要 樹的介紹 二叉樹的介紹 二叉查詢樹的C實現 1. 節點定義 2 遍歷 3. 查詢 4. 最大值和最小值 5. 前驅和後繼 6. 插入 7. 刪除 8. 列印 9. 銷燬二叉樹 完整的實現程式碼 二叉查詢樹的C測試程式 下面對