java-11.二叉树中节点的最大距离

最新推荐文章于 2024-10-18 20:01:16 发布

bylijinnan

最新推荐文章于 2024-10-18 20:01:16 发布

阅读量349

点赞数

分类专栏：微软等面试100题文章标签：数据结构与算法 java

微软等面试100题专栏收录该内容

38 篇文章

订阅专栏

本文介绍了一种算法，用于确定二叉树中从任一节点到叶子节点的最大路径长度。通过递归遍历二叉树，并计算左右子树的最大路径长度来实现。适用于完全二叉树，并展示了如何构建二叉树及查找最大路径长度的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >


import java.util.ArrayList;
import java.util.List;


public class MaxLenInBinTree {

	/*
	 a.			1
	 		   /  \
	 		  2    3
	 		 / \  / \
	 		4   5 6  7
	 	max=4	pass "root"
	 b.			1
	 		   /  \
	 		  2    3
	 		 / \    
	 		4   5    
	 	   /     \
	 	  6       7
	 	 /         \
	 	8           9
	 	max=6. do not pass "root"
	 */
	public static void main(String[] args) {
		int[] a={1,2,3,4,5,6,7};
		//store in LevelOrder,Complete Binary Tree. 0==no child
		int[] b={1,2,3,4,5,0,0,6,0,0,7,0,0,0,0,8,0,0,0,0,0,0,9};
		MaxLenInBinTree m=new MaxLenInBinTree();
		Node aRoot=m.createTree(b);
		m.findMaxLen(aRoot);
		System.out.println(m.maxLen);

	}

	private int maxLen=0;

	public void findMaxLen(Node node){

		if(node==null) return ;

		if(node.getLeft()==null){
			node.setMaxLeftLen(0);
		}
		if(node.getRight()==null){
			node.setMaxRightLen(0);
		}

		if(node.getLeft()!=null){
			findMaxLen(node.getLeft());
		}
		if(node.getRight()!=null){
			findMaxLen(node.getRight());
		}

		if(node.getLeft()!=null){
			int temp=0;
			Node left=node.getLeft();
			if(left.getMaxLeftLen()>left.getMaxRightLen()){
				temp=left.getMaxLeftLen();
			}else{
				temp=left.getMaxRightLen();
			}
			node.setMaxLeftLen(temp+1);
		}
		if(node.getRight()!=null){
			int temp=0;
			Node right=node.getRight();
			if(right.getMaxLeftLen()>right.getMaxRightLen()){
				temp=right.getMaxLeftLen();
			}else{
				temp=right.getMaxRightLen();
			}
			node.setMaxRightLen(temp+1);
		}
		if(maxLen<node.getMaxLeftLen()+node.getMaxRightLen()){
			maxLen=node.getMaxLeftLen()+node.getMaxRightLen();
		}
	}

	public Node createTree(int[] data){
		List<Node> nodeList=new ArrayList<Node>();
		for(int each:data){
			Node n=new Node(each);
			nodeList.add(n);
		}
		int lastRootIndex=data.length/2-1;
		for(int i=0;i<=lastRootIndex;i++){
			Node root=nodeList.get(i);
			Node left=nodeList.get(i*2+1);
			if(left.getData()!=0){
				root.setLeft(left);
			}else{
				root.setLeft(null);
			}
			if(i*2+2<data.length){
				Node right=nodeList.get(i*2+2);
				if(right.getData()!=0){
					root.setRight(right);
				}else{
					root.setRight(null);
				}
			}

		}
		Node root=nodeList.get(0);
		return root;
	}
	class Node{
		private int data;
		private Node left;
		private Node right;
		private int maxLeftLen;//the max length of leftTree
		private int maxRightLen;

		public Node(int i){
			data=i;
		}
		public int getData() {
			return data;
		}
		public void setData(int data) {
			this.data = data;
			this.left=null;
			this.right=null;
		}
		public Node getLeft() {
			return left;
		}
		public void setLeft(Node left) {
			this.left = left;
		}
		public Node getRight() {
			return right;
		}
		public void setRight(Node right) {
			this.right = right;
		}
		public int getMaxLeftLen() {
			return maxLeftLen;
		}
		public void setMaxLeftLen(int maxLeftLen) {
			this.maxLeftLen = maxLeftLen;
		}
		public int getMaxRightLen() {
			return maxRightLen;
		}
		public void setMaxRightLen(int maxRightLen) {
			this.maxRightLen = maxRightLen;
		}
	}
}