树中两个结点的最低公共祖先

情况1：

树为二叉排序树。

思路：从根结点开始和输入的两个结点进行比较，如果当前结点的值比两个结点的值都大，那么最低的祖先肯定在左子树中，于是下一步遍历当前结点的左子结点。如果当前结点的值比两个结点的值都小，那么最低的祖先肯定在右子树种，于是下一步遍历当前结点的右子结点。如果当前结点正好是输入的两个结点之一，说明这两个结点有一个是另一个的祖先，这时输出当前结点的父节点即可。

/*
二叉树的公共祖先系列
	1.二叉树为二叉排序树
by Rowandjj
2014/8/20
*/
#include<iostream>
using namespace std;
typedef struct _NODE_
{
	int data;
	struct _NODE_ *left;
	struct _NODE_ *right;
}BNode,*pBNode,*pTree;
//先序方式构造二叉树
void create(pTree *pT)
{
	int data;
	cin>>data;
	if(data == -1)
	{
		return;
	}
	*pT = (pBNode)malloc(sizeof(BNode));
	if(!pT)
	{
		exit(-1);
	}
	(*pT)->data = data;
	(*pT)->left = NULL;
	(*pT)->right = NULL;
	create(&(*pT)->left);
	create(&(*pT)->right);
}
pBNode findAncestor(pTree pT,pBNode pNode1,pBNode pNode2)
{
	if(pT == NULL || pNode1 == NULL || pNode2 == NULL)
	{
		return NULL;
	}
	if(pT == pNode1 || pT == pNode2)//输入的结点中至少有一个是根，这种情况下无祖先
	{
		return NULL;
	}
	pBNode pParent = NULL;
	int pData1 = pNode1->data;
	int pData2 = pNode2->data;
	if(pData1 > pData2)
	{
		int temp = pData1;
		pData1 = pData2;
		pData2 = temp;
	}
	while(pT != NULL)
	{
		if(pT->data < pData1)//当前结点比输入的两个结点都小
		{//说明在右子树中
			pParent = pT;
			pT = pT->right;
		}else if(pT->data > pData2)//当前结点比输入的两个结点都大
		{//说明在左子树中
			pParent = pT;
			pT = pT->left;
		}else if(pT == pNode1 || pT == pNode2)//当前结点正好是输入的结点之一，说明输入的两个结点一个是另一个的祖先
		{
			return pParent;
		}else//当前结点值在输入的两个结点之间
		{
			return pT;
		}
	}
	return NULL;
}
void display(pTree pT)
{
	if(pT == NULL)
	{
		return;
	}
	if(pT->left)
	{
		display(pT->left);
	}
	cout<<pT->data<<" ";
	if(pT->right)
	{
		display(pT->right);
	}
}
int main()
{
	pTree pT = NULL;
	create(&pT);
	display(pT);
	cout<<"\n";
	pBNode n = (pBNode)malloc(sizeof(BNode));
	if(!n)
	{
		exit(-1);
	}
	n->data = 111;
	pBNode p = findAncestor(pT,n,n);
	if(p != NULL)
	{
		cout<<p->data<<endl;
	}
	else
	{
		cout<<"Not Found\n";
	}
	return 0;
}

情况2：

二叉树是普通二叉树，但是含有指向父节点的指针.

思路：

既然含有指向父节点的指针，那么我们从输入的两个结点分别出发，得到两条到根结点的路径，然后问题转化为求两个单链表的第一个公共结点问题.

代码：

/*
二叉树公共祖先系列
	2.二叉树含有指向父节点的指针
*/
#include<iostream>
using namespace std;
typedef struct _NODE_
{
	int data;
	struct _NODE_ *left;
	struct _NODE_ *right;
	struct _NODE_ *parent;
}Node,*pNode,*pTree;
/*寻找最低公共祖先*/
pNode findAncestor(pTree pT,pNode pNode1,pNode pNode2)
{
	if(pT == NULL || pNode2 == NULL || pNode1 == NULL)
	{
		return NULL;
	}
	if(pT==pNode1 || pT==pNode2)
	{
		return NULL;
	}
	/* 1.计算这两个结点到根结点的路径长度 */
	int len1 = 0,len2 = 0;
	pNode pTemp = pNode1;
	while(pTemp != NULL)
	{
		pTemp = pTemp->parent;
		len1++;
	}
	pTemp = pNode2;
	while(pTemp != NULL)
	{
		pTemp = pTemp->parent;
		len2++;
	}
	/* 2.接下来相当于求两个单链表的公共结点 */
	int dif = len1-len2;
	pNode pLong = pNode1;
	pNode pShort = pNode2;
	if(dif<0)
	{
		pLong = pNode2;
		pShort = pNode1;
		dif = len2-len1;
	}
	while(dif > 0)//快指针先走dif步
	{
		pLong = pLong->parent;
		dif--;
	}
	//两个指针同时走，第一次相遇即为最低公共祖先
	while(pLong != NULL && pShort != NULL && pLong != pShort)
	{
		pLong = pLong->parent;
		pShort = pShort->parent;
	}
	return pLong;
}
/*先序遍历*/
void display(pTree pT)
{
	if(pT == NULL)
	{
		return;
	}
	cout<<pT->data<<" ";
	if(pT->left)
	{
		display(pT->left);
	}
	if(pT->right)
	{
		display(pT->right);
	}
}
/*构建二叉树*/
void create(pTree *pT,pNode pParent)
{
	int data;
	cin>>data;
	if(data == -1)
	{
		return;
	}
	*pT = (pNode)malloc(sizeof(Node));
	if(*pT == NULL)
	{
		exit(-1);
	}
	(*pT)->data = data;
	(*pT)->left = NULL;
	(*pT)->right = NULL;
	(*pT)->parent = pParent;

	create(&(*pT)->left,*pT);
	create(&(*pT)->right,*pT);
}
int main()
{
	pTree pT = NULL;
	create(&pT,NULL);
	pNode p = findAncestor(pT,pT->right,pT->left->right->left->right);
	if(p != NULL)
	{
		cout<<p->data<<endl;
	}else
	{
		cout<<"Not Found..."<<endl;
	}

	display(pT);
	return 0;
}

情况3：

树为普通二叉树，没有指向父节点的指针

思路：

首先第一步仍然需要求到输入的两个结点到根结点的一条路径，然后有了路径就好办了。

我们可以使用一个数组存放路径，然后按照先序遍历的方式得到路径，具体见代码。

代码：

/*
树中两个结点的公共祖先
	3.树为普通二叉树，没有指向父节点的指针
*/
#include<stdio.h>
#include<stdlib.h>
typedef struct _NODE_
{
	int data;
	struct _NODE_ *left;
	struct _NODE_ *right;
}Node,*pNode,*pTree;
/* 在二叉树pT中寻找从根到val的一条路径，path保存路径数组，index为当前数组下标，len为数组长度 */
bool GetNodePath(pTree pT,int val,int *path,int index,int *len)
{
	if(pT == NULL)
	{
		*len = 0;
		return false;
	}
	path[index] = pT->data;

	if(pT->data == val)
	{
		*len = index+1;//index从0开始
		return true;
	}else
	{
		bool can;
		can = GetNodePath(pT->left,val,path,index+1,len);
		if(!can)
		{
			can = GetNodePath(pT->right,val,path,index+1,len);
		}
		return can;
	}
}
/* 寻找最低公共祖先   根据两条路径 */
int findAncestor(int *path1,int len1,int *path2,int len2)
{
	if(path1 == NULL || path2 == NULL || len1 <= 0 || len2 <= 0)
	{
		return 0;
	}
	int minLen = (len1<len2)?len1:len2;
	int i;
	for(i = 0; i < minLen; i++)
	{
		if(path1[i] != path2[i])//第一个不相同的结点的上一个结点即为最低公共祖先
		{
			break;
		}
	}
	return path1[i-1];
}
/*二叉树先序创建*/
void create(pTree *pT)
{
	int data;
	scanf("%d",&data);
	if(data == 0)
	{
		return;
	}
	*pT = (pNode)malloc(sizeof(Node));
	if(*pT == NULL)
	{
		exit(-1);
	}
	(*pT)->data = data;
	(*pT)->left = NULL;
	(*pT)->right = NULL;
	create(&(*pT)->left);
	create(&(*pT)->right);
}
/*先序遍历*/
void display(pTree pT)
{
	if(pT == NULL)
	{
		return;
	}
	printf("%d ",pT->data);
	if(pT->left)
	{
		display(pT->left);
	}
	if(pT->right)
	{
		display(pT->right);
	}
}
/*销毁二叉树*/
void destroy(pTree pT)
{
	if(pT == NULL)
	{
		return;
	}
	if(pT->left)
	{
		destroy(pT->left);
	}
	if(pT->right)
	{
		destroy(pT->right);
	}
	free(pT);
	pT = NULL;
}
int main()
{
	int t;
	while(scanf("%d",&t) != EOF)
	{
		int i;
		int m,n;
		int len1,len2;
		for(i = 0; i < t; i++)
		{
			pTree pT = NULL;
			create(&pT);
			scanf("%d %d",&m,&n);
			int path1[10000];
			int path2[10000];

			GetNodePath(pT,m,path1,0,&len1);
			GetNodePath(pT,n,path2,0,&len2);
			int result = findAncestor(path1,len1,path2,len2);
			if(result != 0)
			{
				printf("%d\n",result);
			}else
			{
				printf("My God\n");
			}
			destroy(pT);
		}
	}
	return 0;
}

树中两个结点的最低公共祖先

时间： 2024-10-03 22:05:16

树中两个结点的最低公共祖先的相关文章

Lowest Common Ancestor of a Binary Search Tree(树中两个结点的最低公共祖先)

题目描述: Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST. According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T tha

求一棵普通树的两个结点的最低公共祖先

一棵普通树,树中的结点没有指向父节点的指针,求一棵普通树的两个结点的最低公共祖先. 代码如下,我太懒没有加注释,大家自己看吧! 1 #include <iostream> 2 #include <list> 3 #include <vector> 4 using namespace std; 5 6 struct TreeNode //节点 7 { 8 char m_nValue; 9 vector<TreeNode*> m_vChildren; 10 };

求树中两个节点的最低公共祖先

情形1:树是搜索二叉树 思路:从树的根节点开始遍历,如果根节点的值大于其中一个节点,小于另外一个节点,则根节点就是最低公共祖先.否则如果根节点的值小于两个节点的值,则递归求根节点的右子树,如果大于两个节点的值则递归求根的左子树.如果根节点正好是其中的一个节点,那么说明这两个节点在一条路径上,所以最低公共祖先则是根节点的父节点 public static BinaryTreeNode getLowestCommonAncestor(BinaryTreeNode rootParent,BinaryT

树中两个节点的最低公共祖先

树是二叉查找树的情况 题目来自LeetCode:https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/ Lowest Common Ancestor of a Binary Search Tree Total Accepted: 3402 Total Submissions: 8709 My Submissions Question Solution Given a binary search t

求解二叉树中两个结点的最低公共父结点

一,问题描述 构建一棵二叉树(不一定是二叉查找树),求出该二叉树中某两个结点的最低公共父结点.借用一张图如下: 结点8 和 结点5 的最低公共父结点为 结点2 二,二叉树的构建 与 求二叉树中第K层结点的个数 文章中的第二点:二叉树构建相同 三,求解最低公共父结点的算法实现 有两种思路,一种是通过中序遍历和后序遍历.由于中序遍历是先左子树中的结点,再访问根,再访问右子树中结点,因此这两个结点的公共父结点一定处于这两个结点之间. 如:中序遍历:8, 4, 9, 2, 5, 1, 6, 3, 7  

二叉树中两个结点最近的公共祖先汇总

一.若二叉树为搜索二叉树 原题链接:https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/#/description Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST. According to the definition of LCA on

寻找二叉树两个节点的最低公共祖先

从root开始遍历,如果n1和n2中的任一个和root匹配,那么root就是LCA. 如果都不匹配,则分别递归左.右子树,如果有一个 key(n1或n2)出现在左子树,并且另一个key(n1或n2)出现在右子树,则root就是LCA.  如果两个key都出现在左子树,则说明LCA在左子树中,否则在右子树. /* 只用一次遍历解决LCA */ #include <iostream> using namespace std; struct Node { struct Node *left, *ri

求两个节点的最低公共祖先

tag: 二叉树 思路一: 分治 思路二:非递归??? package com.zhaochao.tree; /** * Created by zhaochao on 17/1/24. * lowest common ancestor */ public class LCA { // 在root为根的二叉树中找A,B的LCA: // 如果找到了就返回这个LCA // 如果只碰到A,就返回A // 如果只碰到B,就返回B // 如果都没有,就返回null public TreeNode LCARe

树的两个节点的最低公共祖先

Lowest Common Ancestor of a Binary Tree Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to the definition of LCA on Wikipedia: "The lowest common ancestor is defined between two nodes v and w as th