基于二叉链表的二叉树的最近公共祖先问题

最新推荐文章于 2023-10-25 17:11:57 发布
最新推荐文章于 2023-10-25 17:11:57 发布
阅读量398 收藏 6
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/galaxyrt/article/details/118355856
版权

基于二叉链表的二叉树的最近公共祖先问题

描述

在很多基于树的应用算法中，涉及到最近公共祖先问题（Least Common Ancestors，LCA）。对于有根树T的两个结点u、v，最近公共祖先LCA(u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。例如，对于下图所示的二叉树，LCA(C,F)=B，LCA(B,F)=B。

输入

多组数据。每组数据有两行，第一行为二叉树的先序遍历序列，其中左右子树若为空则用‘#’代替；第二行为两个待求最近公共祖先结点的两个结点u和v。当输入只有一个“0”时，输入结束。

输出

每组数据输出两行，第一行为该二叉树的中序遍历序列，第二行为u和v的最近公共祖先结点的值。

输入样例 1 

ABC##DE#G##F###
B F
ABC##D##EF###
C D
0

输出样例 1

CBEGDFA
B
CBDAFE
B

示例一（大佬）

#include<iostream> 
using namespace std;
 
typedef struct BiNode{
   char data;
   struct  BiNode  *lchild,*rchild,*root; 
}BiNode,*BiTree; 
 
void CreateBiTree(BiTree &T,char s[],int &i)
{
	if(s[i]=='#')T=NULL;
	else
	{
		T = new BiNode;
		T->data=s[i];
		CreateBiTree(T->lchild,s,++i);
		CreateBiTree(T->rchild,s,++i);		
	}
}
 
void InOrder(BiTree T)
{
	if(T)
	{
		InOrder(T->lchild);
		cout<<T->data;
		InOrder(T->rchild);
	}
}
 
BiTree ancestor(BiTree T,char p,char q)
{
	if(T==NULL)
		return NULL;
	if(T->data==p||T->data==q)
		return T;
	BiTree left=ancestor(T->lchild,p,q);
	BiTree right=ancestor(T->rchild,p,q);
	if(left==NULL)
		return right;
	if(right==NULL)
		return left;
	return T;
}
 
int main()
{
	char s[100];
	while(cin>>s&&s[0]!='0')
	{
		
		int i=-1;
	  	BiTree T,T1;
		CreateBiTree(T,s,++i);
		char p,q;
		cin>>p>>q;
		T1=ancestor(T,p,q);	
		InOrder(T);
		cout<<endl;
		cout<<T1->data<<endl;
	}
	return 0;
}

示例二

#include<iostream>
using namespace std;
int sum=0;
typedef struct BiTNode{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*Treelist;
void createtree(Treelist &T)
{
	char ch;
	cin>>ch;
	if(ch=='#'||ch=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		createtree(T->lchild);
		createtree(T->rchild); 
	}
}
void show(Treelist &T)
{
	if(T)
	{
		show(T->lchild);
		cout<<T->data;
		show(T->rchild);
	}
}
int close(Treelist &T,char p,char q)
{
    int l=0;
    if(T==NULL) 
		return 0;
    int left = close(T->lchild,p,q);
    int right = close(T->rchild,p,q);
    l = left+right;
    if(T->data == p||T->data == q) 
		l++;
    if(l == 2)
	{
		cout<<T->data<<endl;
		return -1;
	}
    else if(l==3) 
		return -1;
    else
    	return l;
}
int main()
{
    while(1)
    {
    	Treelist T;
    	createtree(T);
    	if(T==NULL)
			break; 
        char p,q;
        cin>>p>>q;
        show(T);
        cout<<endl;
        close(T,p,q);
    }
    return 0;
}

三

#include<iostream>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}*BiTree;
void Create(BiTree &T)
{
	char ch;
	cin>>ch;
	if(ch=='#'||ch=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		Create(T->lchild);
		Create(T->rchild); 
	}
}
void show(BiTree T)
{
	if(T)
	{
		show(T->lchild);
		cout<<T->data;
		show(T->rchild);
	}
}
BiTree zhuixun(BiTree T,char p,char q)
{
	if(T==NULL)
		return NULL;
	if(T->data==p||T->data==q)
		return T;
	BiTree left=zhuixun(T->lchild,p,q);
	BiTree right=zhuixun(T->rchild,p,q);
	if(left==NULL)
		return right;
	if(right==NULL)
		return left;
	return T;
}
int main()
{
	
	while(1)
	{
		BiTree T;
		Create(T);
		if(T==NULL)
			break;
		BiTree p,q;
		q=new BiTNode;
		p=new BiTNode;
		BiTree T1;
		cin>>p->data>>q->data;
		T1=zhuixun(T,p->data,q->data);
		show(T);
		cout<<endl;
		cout<<T1->data<<endl;
	}
	return 0;
}

四

	#include<iostream>
using namespace std;
#define maxsize 1000
typedef struct BiTNode {
	char data;
	BiTNode* lchild, * rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree& T, char S[], int& i)
{
	if (S[i] == '#')
		T = NULL;
	else
	{
		T = new BiTNode;
		T->data = S[i];
		CreateBiTree(T->lchild, S, ++i);
		CreateBiTree(T->rchild, S, ++i);
	}
}
void PreOrderTraverse(BiTree& T) {
	if(T==NULL)return ;
	else ///时刻记住该节点是否为空
	{	
		PreOrderTraverse(T->lchild);
		cout << T->data;
		PreOrderTraverse(T->rchild);
	
	}
}
 
char find_s(BiTree& T,char node1, char node2)
{
	if (T == NULL || node1 == NULL || node2 == NULL)
		return NULL;
	if (node1 == T->data||node2 ==T->data)
		return T->data;
	char cur = NULL;
	char left_lca = find_s(T->lchild, node1, node2);
	char right_lca = find_s(T->rchild, node1, node2);
	if (left_lca && right_lca)
		return T->data;
	if (left_lca == NULL)
		return right_lca;
	else
		return left_lca;
}
int main() {
	
	while (1)
	{
		int i = 0;
		char s[maxsize];
		cin>>s;
		if(s[0]=='0')break;
		BiTree T;
		CreateBiTree(T, s, i);
		char ch0,ch1;
		cin>>ch0>>ch1;
		 PreOrderTraverse(T);
		 cout<<endl; 
		cout<<find_s(T,ch0,ch1);
		cout << endl;
	}
	return 0;
}

五、

#include<bits/stdc++.h>
using namespace std;
 
typedef struct BiTNode
{
    char data;
    BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
 
void Int(BiTree &T)
{
    char c;
    cin>>c;
    if(c == '#') T = NULL;
    else
    {
        T = new BiTNode;
        T->data = c;
        Int(T->lchild);
        Int(T->rchild);
    }
}
 
void Int(BiTree &T,char c)
{
    if(c == '0') T = NULL;
    else if(c == '0') T = NULL;
    else
    {
        T = new BiTNode;
        T->data = c;
        Int(T->lchild);
        Int(T->rchild);
    }
}
 
void Show(BiTree &T)
{
    if(T)
    {
        Show(T->lchild);
        cout<<T->data;
        Show(T->rchild);
    }
}
 
int Search(BiTree &T,char p,char q)
{
    int l=0;
    if(!T) return 0;
    int m = Search(T->lchild,p,q);
    int n = Search(T->rchild,p,q);
    l = m+n;
    if(T->data == p||T->data == q) l++;
    if(l == 2) {cout<<T->data<<endl;return 100;}
    else if(l==100) return 100;
    else
    return l;
}
 
int main()
{
    BiTree T;
    Int(T);
    char i;
    while(T)
    {
        char m,n;
        cin>>m>>n;
        Show(T);
        cout<<endl;
        Search(T,m,n);
        cin>>i;
        Int(T,i);
    }
    return 0;
}

六

#include<iostream>
using namespace std;
#define maxsize 1000
typedef struct BiTNode {
 char data;
 BiTNode* lchild, * rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree& T, char S[], int& i)
{
 if (S[i] == '#')
  T = NULL;
 else
 {
  T = new BiTNode;
  T->data = S[i];
  CreateBiTree(T->lchild, S, ++i);
  CreateBiTree(T->rchild, S, ++i);
 }
}
void PreOrderTraverse(BiTree& T) {
 if(T==NULL)return ;
 else ///时刻记住该节点是否为空
 { 
  PreOrderTraverse(T->lchild);
  cout << T->data;
  PreOrderTraverse(T->rchild);
 
 }
}
 
char find_s(BiTree& T,char node1, char node2)
{
 if (T == NULL || node1 == NULL || node2 == NULL)
  return NULL;
 if (node1 == T->data||node2 ==T->data)
  return T->data;
 char cur = NULL;
 char left_lca = find_s(T->lchild, node1, node2);
 char right_lca = find_s(T->rchild, node1, node2);
 if (left_lca && right_lca)
  return T->data;
 if (left_lca == NULL)
  return right_lca;
 else
  return left_lca;
}
int main() {
 
 while (1)
 {
  int i = 0;
  char s[maxsize];
  cin>>s;
  if(s[0]=='0')break;
  BiTree T;
  CreateBiTree(T, s, i);
  char ch0,ch1;
  cin>>ch0>>ch1;
   PreOrderTraverse(T);
   cout<<endl; 
  cout<<find_s(T,ch0,ch1);
  cout << endl;
 }
 return 0;
}

七、

#include<iostream>
using namespace std;
typedef struct BiTNode
{
 	char data;
 	struct BiTNode *lchild,*rchild;
}*BiTree;
void Create(BiTree &T)
{
 	char ch;
 	cin>>ch;
 	if(ch=='#'||ch=='0')
  	T=NULL;
 	else
 	{
  		T=new BiTNode;
  		T->data=ch;
  		Create(T->lchild);
  		Create(T->rchild); 
 	}
}
void show(BiTree T)
{
 	if(T)
 	{
  		show(T->lchild);
  		cout<<T->data;
  		show(T->rchild);
 	}
}
BiTree LCA(BiTree T,char x,char y)
{
 	if(T==NULL)
  	return NULL;
 	if(T->data==x||T->data==y)
  	return T;
 	BiTree left=LCA(T->lchild,x,y);
 	BiTree right=LCA(T->rchild,x,y);
 	if(left==NULL)
  	return right;
 	if(right==NULL)
  	return left;
 	return T;
}
int main()
{ 
 	while(1)
 	{
  		BiTree T;
  		Create(T);
  		if(T==NULL)
   		break;
  		BiTree m,n;
  		m=new BiTNode;
  		n=new BiTNode;
  		BiTree T1;
  		cin>>n->data>>m->data;
  		T1=LCA(T,m->data,n->data);
  		show(T);
  		cout<<endl;
  		cout<<T1->data<<endl;
 	}
 	return 0;
}

八、

#include<iostream>
 
using namespace std;
 
typedef struct BiTNode{
	struct BiTNode *lchild,*rchild;
	char data; 
}BiTNode,*Bitree;
 
 
void CreateTree(Bitree &T,char ch[],int &i){
	if(ch[i]=='#')
		T=NULL;
		else{
			T=new BiTNode;
			T->data=ch[i];
			CreateTree(T->lchild,ch,++i);
			
			CreateTree(T->rchild,ch,++i);
		}
} 
 
void midOrderTraverse(Bitree& T) {
 	 if(T)
	 {	    
	 	midOrderTraverse(T->lchild);
		cout << T->data;
	 	midOrderTraverse(T->rchild);
	 }
}
 
char find(Bitree& T,char a, char b)
{
	 if (T==NULL||a==NULL||b==NULL)
	  return NULL;
	 if (a==T->data||b==T->data)
	  return T->data;
	 char cur=NULL;
	 char left=find(T->lchild,a,b);
	 char right=find(T->rchild,a,b);
	 if(left&&right)
	  	return T->data;
	 if (left==NULL)
	  	return right;
	 else
	  	return left;
}
int main(){
	
	while(1){
		char ch[1000];
		cin>>ch;
		if(ch[0]=='0')
			break;
			Bitree bt;
			int i=-1;
			CreateTree(bt,ch,++i);
			midOrderTraverse(bt);//中序遍历 
			
			cout<<endl;
			char a,b;
			cin>>a>>b;
			 
			cout<<find(bt,a,b);
			cout<<endl;
	}
	return 0;
}

九

#include<iostream>
 
using namespace std;
 
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
 
void Create(BiTree &T,char S[],int &i)
{
	if(S[i]=='#') T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		Create(T->lchild,S,++i);
		Create(T->rchild,S,++i);
	}
}
 
void InOrderTraverse(BiTree T)
{
	if(T)
	{
		InOrderTraverse(T->lchild);
		cout<<T->data;
		InOrderTraverse(T->rchild);
	}
}
 
char LSA(BiTree& T,char node1, char node2)
{
	if(T==NULL||node1==NULL||node2==NULL) return NULL;
	if(node1==T->data||node2==T->data) return T->data;
	char cur=NULL;
	char left_lca=LSA(T->lchild,node1,node2);
	char right_lca=LSA(T->rchild,node1,node2);
	if(left_lca&&right_lca) return T->data;
	if(left_lca==NULL) return right_lca;
	else return left_lca;
}
 
int main()
{
	char S[1000];
	while(cin>>S&&S[0]!='0')
	{
		int i=-1;
		char ch1,ch2;
		BiTree T;
		Create(T,S,++i);
		cin>>ch1>>ch2;
		InOrderTraverse(T);
		cout<<endl; 
		cout<<LSA(T,ch1,ch2);
		cout<<endl;
	}
	return 0;
}

十、

#include<iostream> 
using namespace std;
#define MAXSIZE 1000
 
typedef struct BiNode{
   	char data;
  	struct  BiNode  *lchild,*rchild,*root; 
}BiNode,*BiTree; 
 
void CreateBiTree(BiTree &T,char ch[],int &i)
{
 	if(ch[i]=='#')T=NULL;
 	else
 	{
	  	T = new BiNode;
	  	T->data=ch[i];
	  	CreateBiTree(T->lchild,ch,++i);
	  	CreateBiTree(T->rchild,ch,++i);  
 	}
}
 
BiTree SeekBiTree(BiTree T,char t1,char t2)
{
 	if(T==NULL)
  		return NULL;
 	if(T->data==t1||T->data==t2)
 		return T;
 	if(T==NULL)
  		return NULL;
 	BiTree L=SeekBiTree(T->lchild,t1,t2);
 	BiTree R=SeekBiTree(T->rchild,t1,t2);
 	if(L==NULL)
 		return R;
 	if(R==NULL)
  		return L;
 	return T;
}
 
void InorderBiTree(BiTree T)
{
 	if(T)
 	{
  		InorderBiTree(T->lchild);
  		cout<<T->data;
  		InorderBiTree(T->rchild);
 	}
}
 
int main()
{
	char ch[MAXSIZE];
	cin>>ch;
 	while(ch[0]!='0')
 	{
 		char t1,t2;
  		int j=-1;
  		BiTree T,S;
  		CreateBiTree(T,ch,++j);
  		cin>>t1>>t2;
  		S=SeekBiTree(T,t1,t2); 
  		InorderBiTree(T);
  		cout<<endl;
  		cout<<S->data<<endl;
  		cin>>ch;
 	}
 	return 0;
}

 

Pink&Sakura
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
二叉树的公共祖先
weixin_54383080的博客
08-16 753
本文首先会介绍什么是最近公共祖先，接着将会针对该问题介绍几种求解方法，也是本文的核心内容。
在二叉树(搜索树)中找到两个节点的最近公共祖先(剑指offer)
bug郭的博客
06-24 2231
题目链接 \ 时间复杂度最坏情况递归遍历完所有节点! 空间复杂度,递归深度最坏为 时间复杂度: 最坏情况,遍历完所有节点,也就是二叉树单分支,变成了链表,所以需要比较所有节点! 空间复杂度:最坏情况,所有节点都记录保存! 在二叉树中找到两个节点的最近公共祖先 题目链接描述:这里和上面的搜索二叉树不同,不能直接利用搜索二叉树的特性,直接找到该路径!我们这里只是普通的二叉树,需要遍历所有的节点,然后将其路径找出!而我们知道找路径就是找到他这一条路径的祖先,也就是说将每个节点的父节点关系保存即可!我们
二叉搜索树最近公共祖先
最新发布
qq_30719017的博客
10-25 93
4.u,v数值分布在当前根节点两侧，此时根据二叉搜索树的性质，当前根节点就是它们的公共祖先。分析：现假设u<旧根<v,此时如果往旧根左边子树递归的话，新根以及其下面所有节点都不可能有大于旧根的值，3.u,v中某一个是当前根节点,此时是递归的一个出口，当前根节点就是最近公共祖先。1.u,v比当前根节点都大，此时向右子树递归。2.u,v比当前根节点都小，此时向左子树递归。一.u和v某一个在二叉树中不存在。二.u,v在二叉树中存在的情况下。同理，不可能在旧根的右边子树找到u.故不可能在旧根的左边子树找到v。
【PTA】二叉树的层次遍历
qq_51669241的博客
05-07 2626
二叉树的层次遍历 编写程序，要求实现 （1）按先序遍历序列建立二叉树的二叉链表；（2）按层次遍历二叉树。 C++： 构成二叉链表的结点类代码如下： typedef struct BiNode { char data; //结点数据域 struct BiNode *lchild,*rchild; //左右孩子指针 }BiTNode,*BiTree; 按加入空树信息的先序遍历序列建立二叉树的二叉链表代码提供如下： //先序遍历序列建立二叉链表 void C
一般二叉树求最近公共祖先（最简单的代码）
kellen_f的博客
07-21 1992
当遍历到一个root点的时候，1.判断root是不是null如果root为null，那么就无所谓祖先节点，直接返回null就好了2.如果root的左子树存在p，右子树存在q，那么root肯定就是最近祖先3.如果pq都在root的左子树，那么就需要递归root的左子树，右子树同理TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, Tr
寻找二叉树两结点最近的祖先
05-11
（1）拟定合适的二叉树的输入形式和构造算法； （2）能够以直观的形式观察所建立的二叉树的结构；
二叉树中两结点最近的共同祖先算法
12-22
拟定出合适的二叉树的输入形式； 　构造出相应的求共同祖先的算法； 　能够以直观的形式观察到所建立的二叉树； 采用Microsoft Visual C++ 6.0 编译环境进行调试运行。
二叉排序树与平衡二叉树的实现
12-26
题　目 二叉排序树与平衡二叉树的实现 1、课程设计的目的 使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法。 使学生掌握软件设计的基本内容...
c++数据结构二叉树
01-06
2． 实现二叉链表的初始化算法、二叉树空的判断算法； 3． 实现二叉树的先序遍历算法、中序遍历算法和后序遍历算法； 4． 利用某遍历算法实现计算二叉树中叶子结点、度为2的结点和度为1的结点的个数。 5． 求二叉树...
二叉树的相关操作
09-03
本程序包括二叉树的一些常见的相关操作，比如非递归建立二叉树，二叉树的非递归遍历，非递归求二叉树的叶子数目，层数，任意两个节点的公共祖先，跟到叶子节点的所有路径，根据中序和后序的遍历结果建立二叉树等等。
二叉树的最近公共祖先
peko1的博客
03-26 2383
假设我们需要找到结点p，q的最近公共祖先，我们可以发现二叉树的最近公共祖先满足：此结点的左结点和右节点分别存在p，q或者此节点恰好是p，q之一并且他的左右结点之一恰好是另一结点。 我们假设fleft==true表示左节点或左节点的子节点中存在其中一个元素，fleft == false则表示左节点或左节点的子节点中不存在元素，fright同理，则判断一个结点是否最近公共祖先结点的判断条件是： (fleft(fleft(fleft&&fright)∣∣((x=p)∣∣(x=q)frigh..
C++实现二叉树及其递归先序遍历、中序遍历、后续遍历和层次遍历
火锅国刘dada的博客
05-23 1089
先序遍历、中序遍历、后序遍历（递归），层次遍历 代码： #include <iostream> using namespace std; #define MAXSIZE 10 //二叉树节点 typedef struct biNode{ char data; biNode* lchild; biNode* rchild; }biNode, *biTree; //队列，层次遍历时使用 class queue { public: //初始化 void InitQueue() .
数据结构——（树与二叉树）已知二叉树，找出二叉树中给定两个结点的最近公共祖先
qq_39690007的博客
09-03 446
题目：已知二叉树，找出二叉树中给定两个结点的最近公共祖先 思想：遍历二叉树，利用栈保存结点，然后对栈进行查找 代码展示： void findWay(BiTree T,Stack &S,int x,int &finish) { int e; if(T==NULL || finish==1) { return ; } Push(S...
在二叉树中找到两个节点的最近公共祖先
OY_palada
08-30 8132
程序员代码面试指南（左程云）读书笔记 第三章 在二叉树中找到两个节点的最近公共祖先 题目：       给定一棵二叉树的头节点head,以及这棵二叉树的两个节点o1和o2,请返回o1和o2的最近公共祖先节点。 解答：        后序遍历二叉树，假设遍历到的当前结点为cur，因为是后序遍历，所以先处理cur的两颗子树，假设处理cur左子树时返回left，处理右子树时返回right.
【二叉树】二叉树的最近公共祖先
Coder Wu的博客
05-09 399
一、题目 力扣原题：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/ 二、递归 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x;
（二叉树）二叉树的最近公共祖先
热门推荐
HerofH_的博客
01-03 2万+
题目描述 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root = [3,...
二叉树最近公共祖先
Futureing的博客
06-24 2397
递归与非递归方式实现二叉树最近公共祖先
寻找二叉树中两个节点的最近公共祖先节点
qq_39715645的博客
04-05 428
非递归寻找两个节点的最近公共祖先节点 上一篇博文给出了寻找一个结点的所有祖先节点，那么求两个节点的最近公共祖先就很容易了，首先后序遍历找到两个节点各自的祖先列表，都存在了栈中，越靠近栈顶的元素就离对应节点越近，所以只需要将两个栈元素出栈知道栈顶元素第一次相等就可以找到最近公共祖先了。 #include <iostream> #include <stack> using n...
对二叉链表表示的二叉树，求两个节点最近的公共祖先
05-30
对于二叉链表表示的二叉树，可以通过递归的方式来求两个节点的最近公共祖先。 假设要求节点 p 和节点 q 的最近公共祖先，可以分为以下情况： 1. 如果当前节点为空，直接返回空。 2. 如果当前节点为 p 或 q 中的任意一个，直接返回当前节点。 3. 分别在左子树和右子树中递归查找节点 p 和节点 q。 4. 如果节点 p 和节点 q 分别在当前节点的左子树和右子树中，当前节点即为最近公共祖先。 5. 如果节点 p 和节点 q 都在当前节点的左子树中，递归查找左子树。 6. 如果节点 p 和节点 q 都在当前节点的右子树中，递归查找右子树。 具体实现可以参考以下代码： ``` struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { if (root == NULL || root == p || root == q) { return root; } TreeNode* left = lowestCommonAncestor(root->left, p, q); TreeNode* right = lowestCommonAncestor(root->right, p, q); if (left != NULL && right != NULL) { return root; } else if (left != NULL) { return left; } else { return right; } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值