Java，实现得到二叉树的最近公共祖先节点

最新推荐文章于 2023-03-09 10:58:41 发布
最新推荐文章于 2023-03-09 10:58:41 发布
阅读量492 收藏 3
点赞数 3
分类专栏： # 树 # 递归 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45986454/article/details/110077369
版权
数据结构 同时被 3 个专栏收录
37 篇文章 0 订阅
订阅专栏
树
24 篇文章 0 订阅
订阅专栏
递归
23 篇文章 0 订阅
订阅专栏

标题：Java，实现得到二叉树的最近公共祖先节点

一、方法四种：

在这里插入图片描述具体代码见下面：

首先做这个题目，感觉知道这个会比较好:
//供参考的后序迭代输出二叉树的所有节点

//供参考的后序迭代输出二叉树的所有节点
public void postOrder(TreeNode head){
	if(head == null){
		return ;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);

	while(!s.isEmpty()){
		TreeNode p = s.peek();
		if(p.left != null){
			s.push(p.left);
		}else{
			//System.out.print(p.val + " ");
			while(p.right == null){
				TreeNode last = s.pop();
				System.out.print(last.val + " ");
				
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					System.out.print(last.val + " ");
				}
				
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
				//System.out.print(p.val + " ");
			}			
		}		
	}
}

1）方法一：递归
执行用时：7 ms, 在所有 Java 提交中击败了99.85% 的用户
内存消耗：40.5 MB, 在所有 Java 提交中击败了82.40% 的用户

/*
方法一：递归
执行用时：7 ms, 在所有 Java 提交中击败了99.85% 的用户
内存消耗：40.5 MB, 在所有 Java 提交中击败了82.40% 的用户
*/
public TreeNode getCommonNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null){
		return null;
	}else{
		if(head.val == p1.val || head.val == p2.val){  //如果条件满足，return 此节点
			return head;
		}
		TreeNode n1 = this.getCommonNode(head.left, p1, p2);
		TreeNode n2 = this.getCommonNode(head.right, p1, p2);
		if(n1 != null && n2 != null){   //此外的条件，都需要遍历完 左右的节点才知道
			return head;
		}
			
		return n1 == null? n2 : n1;
	}
}

2）方法二：得到两个list
执行用时：16 ms, 在所有 Java 提交中击败了6.76% 的用户
内存消耗：39.1 MB, 在所有 Java 提交中击败了99.58% 的用户

/*
方法二：得到两个list
执行用时：16 ms, 在所有 Java 提交中击败了6.76% 的用户
内存消耗：39.1 MB, 在所有 Java 提交中击败了99.58% 的用户
*/
public TreeNode prePostOrderTocommonTreeNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null || p1 == null || p2 == null){
		return null;
	}
	List<TreeNode> list1 = this.prePostOrderToList(head, p1);
	List<TreeNode> list2 = this.prePostOrderToList(head, p2);

	TreeNode node = null;
	for(int i = list1.size() - 1, j = list2.size() - 1; i >= 0 && j >= 0; i--, j--){
		if(list1.get(i) == list2.get(j)){ //若两个值一样，则继续遍历，保存元素，若不一样，则说明node为公共祖先节点
			node = list1.get(i);
		}else{
			break;
		}
	}

	return node;
}

/*
先序遍历[后序的思想]，得到list
*/
public List<TreeNode> prePostOrderToList(TreeNode head, TreeNode pNode){
	List<TreeNode> list = new ArrayList<>();
	if(head == null || pNode == null){
		return list;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);

	while(!s.isEmpty()){
		TreeNode p = s.peek();
		System.out.print(p.val + " ");
		if(pNode.val == p.val){
			break;
		}
		if(p.left != null){
			s.push(p.left);
		}else{
			while(p.right == null){
				TreeNode last = s.pop();
				//System.out.print(last.val + " ");
				
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					//System.out.print(last.val + " ");
				}
				
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
			}	
			if(s.isEmpty()){
				break;
			}else {
				s.push(p.right);
			}			
		}		
	}
	Iterator<TreeNode> it = s.iterator();
	while(it.hasNext()){
		list.add(it.next());
	}
	
	return list;
}

3）方法三：迭代 【先序的后序写法】 1122之前的写法
思想：通过先序遍历，先找到一个满足条件的node，
继续遍历:
若不需要需要退栈，找到了再次满足条件的，return node，
若需要退栈，pop出 node，则取node = s.peek();

执行用时：9 ms, 在所有 Java 提交中击败了29.26% 的用户
内存消耗：39.5 MB, 在所有 Java 提交中击败了98.93% 的用户

/*
方法三：迭代 【先序的后序写法】  1122之前的写法
思想：通过先序遍历，先找到一个满足条件的node，
继续遍历:
若不需要需要退栈，找到了再次满足条件的，return node，
若需要退栈，pop出 node，则取node = s.peek();

执行用时：9 ms, 在所有 Java 提交中击败了29.26% 的用户
内存消耗：39.5 MB, 在所有 Java 提交中击败了98.93% 的用户
*/
public TreeNode prePostOrderTocommonNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null || p1 == null || p2 == null){
		return null;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);
	int count = 0;
	TreeNode node = null;
	
	while(!s.isEmpty()){
		TreeNode p = s.peek();
		System.out.print(p.val + " ");
		//判断是否满足条件
		if(p.val == p1.val || p.val == p2.val){
			count++;
			if(count == 1){
				node = p;
			}else {
				return node;
			}
		}
		
		if(p.left != null){
			s.push(p.left);
		}else{
			while(p.right == null){
				TreeNode last = s.pop();
				//System.out.print(last.val + " ");
				//重新为node赋值
				if(node != null && node.val == last.val){
					node = null;
				}
				
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					//System.out.print(last.val + " ");
					//重新为node赋值
					if(node != null && node.val == last.val){
						node = null;
					}
				}
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
				//为node赋值
				if(node == null){
					node = p;
				}
			}
			if(s.isEmpty()){
				break;
			}else {
				s.push(p.right);
			}
						
		}		
	}
	return null;
}

4）方法四：迭代 【中序的后序写法】 1122写法 【很明显不需要这样通过中序遍历解题，直接通过上述的先序遍历即可】
思想：通过中序遍历，先找到一个满足条件的node，
继续遍历:
若不需要需要退栈，找到了再次满足条件的，return node，
若需要退栈，pop出 node，则取node = s.peek();

执行用时：10 ms, 在所有 Java 提交中击败了23.24% 的用户
内存消耗：38.9 MB, 在所有 Java 提交中击败了99.76% 的用户

/*
方法四：迭代 【中序的后序写法】  1122写法  【很明显不需要这样通过中序遍历解题，直接通过上述的先序遍历即可】
思想：通过中序遍历，先找到一个满足条件的node，
继续遍历:
若不需要需要退栈，找到了再次满足条件的，return node，
若需要退栈，pop出 node，则取node = s.peek();

执行用时：10 ms, 在所有 Java 提交中击败了23.24% 的用户
内存消耗：38.9 MB, 在所有 Java 提交中击败了99.76% 的用户
*/
public TreeNode inPostOrderToCommonNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null || p1 == null || p2 == null){
		return null;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);
	int count = 0;
	TreeNode node = null;
	
	while(!s.isEmpty()){
		TreeNode p = s.peek();
		if(p.left != null){
			s.push(p.left);
		}else{
			System.out.print(p.val + " ");
			//判断是否找到
			if(p.val == p1.val || p.val == p2.val){
				count++;
				if(count == 1){
					node = p;
				}else{
					return node;
				}
			}
			
			while(p.right == null){
				TreeNode last = s.pop();
				//System.out.print(last.val + " ");
				//将node-》null
				if(node != null && last.val == node.val){
					node = null;
				}
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					//System.out.print(last.val + " ");
					//将node-》null
					if(node != null && last.val == node.val){
						node = null;
					}
				}
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
				System.out.print(p.val + " ");
				if(node == null){
					node = p;
				}
				//判断是否找到
				if(p.val == p1.val || p.val == p2.val){
					count++;
					if(count == 1){
						node = p;
					}else{
						return node;
					}
				}
			}	
			
			if(s.isEmpty()){
				break;
			}else {
				s.push(p.right);
			}			
		}		
	}
	
	return null;
}

完整示例代码：

/*
方法一：递归
执行用时：7 ms, 在所有 Java 提交中击败了99.85% 的用户
内存消耗：40.5 MB, 在所有 Java 提交中击败了82.40% 的用户
*/
public TreeNode getCommonNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null){
		return null;
	}else{
		if(head.val == p1.val || head.val == p2.val){  //如果条件满足，return 此节点
			return head;
		}
		TreeNode n1 = this.getCommonNode(head.left, p1, p2);
		TreeNode n2 = this.getCommonNode(head.right, p1, p2);
		if(n1 != null && n2 != null){   //此外的条件，都需要遍历完 左右的节点才知道
			return head;
		}
			
		return n1 == null? n2 : n1;
	}
}

/*
方法二：得到两个list
执行用时：16 ms, 在所有 Java 提交中击败了6.76% 的用户
内存消耗：39.1 MB, 在所有 Java 提交中击败了99.58% 的用户
*/
public TreeNode prePostOrderTocommonTreeNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null || p1 == null || p2 == null){
		return null;
	}
	List<TreeNode> list1 = this.prePostOrderToList(head, p1);
	List<TreeNode> list2 = this.prePostOrderToList(head, p2);

	TreeNode node = null;
	for(int i = list1.size() - 1, j = list2.size() - 1; i >= 0 && j >= 0; i--, j--){
		if(list1.get(i) == list2.get(j)){ //若两个值一样，则继续遍历，保存元素，若不一样，则说明node为公共祖先节点
			node = list1.get(i);
		}else{
			break;
		}
	}

	return node;
}

/*
先序遍历，得到list
*/
public List<TreeNode> prePostOrderToList(TreeNode head, TreeNode pNode){
	List<TreeNode> list = new ArrayList<>();
	if(head == null || pNode == null){
		return list;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);

	while(!s.isEmpty()){
		TreeNode p = s.peek();
		System.out.print(p.val + " ");
		if(pNode.val == p.val){
			break;
		}
		if(p.left != null){
			s.push(p.left);
		}else{
			while(p.right == null){
				TreeNode last = s.pop();
				//System.out.print(last.val + " ");
				
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					//System.out.print(last.val + " ");
				}
				
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
			}	
			if(s.isEmpty()){
				break;
			}else {
				s.push(p.right);
			}			
		}		
	}
	Iterator<TreeNode> it = s.iterator();
	while(it.hasNext()){
		list.add(it.next());
	}
	
	return list;
}


/*
方法三：迭代 【先序的后序写法】  1122之前的写法
思想：通过先序遍历，先找到一个满足条件的node，
继续遍历:
若不需要需要退栈，找到了再次满足条件的，return node，
若需要退栈，pop出 node，则取node = s.peek();

执行用时：9 ms, 在所有 Java 提交中击败了29.26% 的用户
内存消耗：39.5 MB, 在所有 Java 提交中击败了98.93% 的用户
*/
public TreeNode prePostOrderTocommonNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null || p1 == null || p2 == null){
		return null;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);
	int count = 0;
	TreeNode node = null;
	
	while(!s.isEmpty()){
		TreeNode p = s.peek();
		System.out.print(p.val + " ");
		//判断是否满足条件
		if(p.val == p1.val || p.val == p2.val){
			count++;
			if(count == 1){
				node = p;
			}else {
				return node;
			}
		}
		
		if(p.left != null){
			s.push(p.left);
		}else{
			while(p.right == null){
				TreeNode last = s.pop();
				//System.out.print(last.val + " ");
				//重新为node赋值
				if(node != null && node.val == last.val){
					node = null;
				}
				
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					//System.out.print(last.val + " ");
					//重新为node赋值
					if(node != null && node.val == last.val){
						node = null;
					}
				}
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
				//为node赋值
				if(node == null){
					node = p;
				}
			}
			if(s.isEmpty()){
				break;
			}else {
				s.push(p.right);
			}
						
		}		
	}
	return null;
}

/*
方法四：迭代 【中序的后序写法】  1122写法  【很明显不需要这样通过中序遍历解题，直接通过上述的先序遍历即可】
思想：通过中序遍历，先找到一个满足条件的node，
继续遍历:
若不需要需要退栈，找到了再次满足条件的，return node，
若需要退栈，pop出 node，则取node = s.peek();

执行用时：10 ms, 在所有 Java 提交中击败了23.24% 的用户
内存消耗：38.9 MB, 在所有 Java 提交中击败了99.76% 的用户
*/
public TreeNode inPostOrderToCommonNode(TreeNode head, TreeNode p1, TreeNode p2){
	if(head == null || p1 == null || p2 == null){
		return null;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);
	int count = 0;
	TreeNode node = null;
	
	while(!s.isEmpty()){
		TreeNode p = s.peek();
		if(p.left != null){
			s.push(p.left);
		}else{
			System.out.print(p.val + " ");
			//判断是否找到
			if(p.val == p1.val || p.val == p2.val){
				count++;
				if(count == 1){
					node = p;
				}else{
					return node;
				}
			}
			
			while(p.right == null){
				TreeNode last = s.pop();
				//System.out.print(last.val + " ");
				//将node-》null
				if(node != null && last.val == node.val){
					node = null;
				}
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					//System.out.print(last.val + " ");
					//将node-》null
					if(node != null && last.val == node.val){
						node = null;
					}
				}
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
				System.out.print(p.val + " ");
				if(node == null){
					node = p;
				}
				//判断是否找到
				if(p.val == p1.val || p.val == p2.val){
					count++;
					if(count == 1){
						node = p;
					}else{
						return node;
					}
				}
			}	
			
			if(s.isEmpty()){
				break;
			}else {
				s.push(p.right);
			}			
		}		
	}
	
	return null;
}





//供参考的后序迭代输出二叉树的所有节点
public void postOrder(TreeNode head){
	if(head == null){
		return ;
	}
	Deque<TreeNode> s = new LinkedList<>();
	s.push(head);

	while(!s.isEmpty()){
		TreeNode p = s.peek();
		if(p.left != null){
			s.push(p.left);
		}else{
			//System.out.print(p.val + " ");
			while(p.right == null){
				TreeNode last = s.pop();
				System.out.print(last.val + " ");
				
				while(!s.isEmpty() && s.peek().right == last){
					last = s.pop();
					System.out.print(last.val + " ");
				}
				
				if(s.isEmpty()){
					break;
				}
				p = s.peek();
				//System.out.print(p.val + " ");
			}			
		}		
	}
}
jay编程
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
floatLig#JavaLearning#236.二叉树的最近公共祖先1
07-25
中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以
二叉树的最近公共祖先【Java实现】
Infinity_and_beyond的博客
03-05 864
现有一棵n个结点的二叉树（结点编号为从0到n-1，根结点为0号结点），求两个指定编号结点的最近公共祖先。注：二叉树上两个结点A、B的最近公共祖先是指：二叉树上存在的一个结点P，使得P既是A的祖先，又是B的祖先，并且P需要离根结点尽可能远（即层号尽可能大）。
求二叉树的最近公共祖先算法 （java代码）
whispeImp的博客
05-14 460
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。 例如图中的二叉树节点5，4的公共祖先是5。节点7，1的公共祖先是3。 算法一： 首先分别记录从两个子节点到根节点的路径存储在两个链表，然后这个问题可以转化为求两个链表的公共结点。 记录路径算法（递归） public boolean getPath(List<TreeNode> list,T
二叉树两个节点求最近的公共祖先节点java代码实现
Bright_Man的博客
08-26 2852
LCA三种情况下的求解思路和实现代码
java求最近的共同祖先节点_二叉树中两个节点的最近公共祖先
weixin_33338498的博客
02-25 619
一、递归版本思想：假设根结点为root，其中给定的两个结点分别为A和B，它们分别都不为null。如果当前结点p为null，那么直接返回null，如果当前结点p是给定的结点中的其中一个结点，那么直接返回当前结点p(如果p是根结点，程序一次就返回了，下面的递归也不会出现)。如果当前节点不是A和B中的一个，那么需要分别去查找p的左右子树，看看是否包含A或者B，查询左右子树后，如果查询左子树和查询右子树的...
Leetcode236_二叉树的最近公共祖先
qq_41864967的博客
10-22 223
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树:root =[3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 ...
Java算法学习13——最近公共祖先
Warddamn的博客
03-29 6093
一、算法思路： 本节主要为最近公共祖先，算法利用的为递归的方式，总体思路就是先从根节点出发，然后判断根节点的子节点是否包含需要寻找最近公共祖先的左右节点，如果包含的话则往下一层继续寻找，具体的思路可以分成如下几步： 先判断根节点是否为空，如果为空的话即返回空 在判断根结点是否为左右节点的其中一个，如果是，那么这个根节点就必为最近公共祖先 如果不满足1,2说明最近公共祖先在根节点的左右子树中，因此分别递归遍历根节点的左右子树 Treenode left=lowestCommonAnces
java数据结构与算法之最近公共祖先问题
wenpan的博客
03-21 696
①、问题描述 给你两个节点node1,node2，这两个节点都在树上，再给你一个节点head，head表示二叉树的头节点，请返回他们【最近的公共祖先】 ②、核心点分析 如果我们能顺着某个node向上找到他的父亲节点就好了。如果能从某个节点开始向上找到他的parent节点，那么这个题就和单链表相交问题一样了，变得非常简单了 所以，对于这种二叉树结构，我们只要知道【二叉树的头节点】，那么我们就可以【遍历】这棵二叉树。然后利用【HashMap结构】来存放每个节点的父子关系，这样的话，对于每一个节点，我们都可以找
剑指 Offer 68 - I. 二叉搜索树的最近公共祖先（java解题）
weixin_44201830的博客
03-09 238
leetcode《图解数据结构》剑指 Offer 68 - I. 二叉搜索树的最近公共祖先（java解题）的解题思路和java代码，并附上java中常用数据结构的功能函数。
Java二叉树的最近公共祖先
qq_42900213的博客
07-13 373
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 执行用时：6 ms, 在所有 Java 提交中击败了100.00%的用户内存消耗：41.8 MB, 在所有 Java 提交中击败了30.93%的用户通过测试用例：31 / 31.........
基于链表节点实现二叉树节点(Java源码)
01-20
* 基于链表节点实现二叉树节点 */ package dsa; public class BinTreeNode implements BinTreePosition { protected Object element;//该节点中存放的对象 protected BinTreePosition parent;//父亲 ...
二叉树节点ADT接口(Java算法源码)
01-20
* 二叉树节点ADT接口 */ package dsa; public interface BinTreePosition extends Position { //判断是否有父亲（为使代码描述简洁） public boolean hasParent(); //返回当前节点的父节点 public ...
百度地图开发java源码-blog-backup:学习文章，也是我博客的备份
06-06
树中两个节点的最低公共祖先 判断是否为平衡二叉树-解法二 机器人运动的范围 矩阵中的路径 滑动窗口最大值 数据流的中位数 删除链表中重复的节点[无序的情况下-HashSet] 二. Notes for Android Heros 三. Notes for ...
leetcode-solutions:我对leetcode问题的解决方案
05-12
235.二叉搜索树的最低共同祖先 公认 141.链表周期 公认 121.买卖股票的最佳时间 公认 21.合并两个排序列表 公认 345.反串的元音 公认 24.成对交换节点 公认 342.四次方 公认 107.二叉树级顺序遍历II 公认 27.删除...
Java实现给你一个数组，生成一个对应的二叉树
热门推荐
weixin_45986454的博客
03-03 1万+
标题:Java实现给你一个数组，生成一个对应的二叉树 测试用例： 用的是层次遍历的思想： 层次遍历，一种不带返回值的，一种带返回值的【比前一种多了些思考】 层次遍历的代码： //层次遍历 public void levelOrder(TreeNode root){ // Deque<TreeNode> s = new LinkedList<>(); Queue<TreeNode> q = new LinkedList<>
java实现判断是否为二叉搜索树
weixin_45986454的博客
11-20 1426
标题:java实现判断是否为二叉搜索树 一、分析 1）第一种： 对于二叉搜索树，首先想到的的是中序遍历，得到的是一个有序序列。 所以方法可以是使用中序的递归，非递归进行实现，只要看是否为有序即可。 方法一：中序非递归遍历，保存最小值为long cur = Long.MIN_VALUE;每次遍历得到一个节点的值时，比较是否大于当前最小值cur，满足条件则更新当前最小值。 /** * 使用非递归实现 迭代版的【非递归中序遍历】，简单，容易实现 * 执行用时：2 ms, 在所有 Java 提交中击败
Java实现判断一棵树是否为BST二叉搜索树
weixin_45986454的博客
12-06 914
标题：Java实现判断一棵树是否为BST二叉搜索树 题目：判断是否为二叉搜索树 98. 验证二叉搜索树 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \
Java实现二叉树的中序遍历
weixin_45986454的博客
10-22 765
标题:Java实现二叉树的中序遍历 /** * 我的二叉树 【中序遍历】 * @author dell * */ public class TestMyTreeB02 { /** * 测试遍历二叉树的中序遍历【先输出节点的值】 * @param p */ public void midorder(IntNode p) { if(p == null) { return ; }else { this.midorder(p.left); System.out.p
Java实现：最近公共祖先节点
weixin_45986454的博客
11-13 575
标题：Java实现：最近公共祖先节点 一、方法一 ,很容易想到，但不是最优解 思想：找到两个满足条件的节点，得到他们的祖先节点 1）.使用非递归的后序遍历实现【因为先序遍历，直接删节点就行了，不需要后序遍历那么的麻烦，中序也同样】 2）eg：栈中为：1-> 2 -> 3 那么说此节点数组中存放的为3，2，1因为 这样才是最近的公共祖先节点【注意：要包含自身】 3）最后通过两个for循环，得到TreeNode /* * 使用后序遍历，得到两个链表 * * 执行用时：44 ms,
JAVA二叉树的最近公共祖先
最新发布
07-28
Java中二叉树的最近公共祖先可以通过递归来解决。首先，我们需要定义一个TreeNode类表示二叉树的节点，其中包含值和左右子节点的引用。下面是一个示例代码： ```java class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; } } ``` 接下来，我们可以实现一个递归函数来找到最近公共祖先： ```java public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { // 判断当前节点是否为空或者等于p或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; } // 如果只有左子树找到了最近公共祖先，则返回左子树的结果 if (left != null) { return left; } // 如果只有右子树找到了最近公共祖先，则返回右子树的结果 if (right != null) { return right; } // 如果左右子树都没有找到最近公共祖先，则返回null return null; } ``` 这个递归函数的基本思路是： - 当前节点为空或者等于p或q时，直接返回当前节点； - 在左子树中寻找最近公共祖先； - 在右子树中寻找最近公共祖先； - 如果左子树和右子树都找到了最近公共祖先，则当前节点就是最近公共祖先； - 如果只有左子树找到了最近公共祖先，则返回左子树的结果； - 如果只有右子树找到了最近公共祖先，则返回右子树的结果； - 如果左右子树都没有找到最近公共祖先，则返回null。 你可以调用这个函数来找到二叉树中任意两个节点的最近公共祖先。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值