微软面试100题系列---求二叉树中节点的最大距离

题目

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义”距离”为两节点之间边的个数。写一个程序求一棵二叉树中相距最远的两个节点之间的距离；

实现

分析

计算一个二叉树的最大距离有两个情况:

情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。

情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者。



只需要计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

方法1

思路：二叉树的操作一般都是递归实现的，此时也采用递归思想。

对于以node节点为根节点的树，首先求左子树距根的最大距离maxLeft；然后求右子树距根的最大距离maxRight；则以node为根的二叉树中节点最大距离为=maxLeft+maxRight；

对于每个节点，都记录了左子树到该节点的最大距离，右子树到该节点的最大距离；

代码：

public class Num11 {

public static int maxLen=0;
public static void main(String[] args) {
Node root_1=createTree_1();
Node root_2=createTree_2();
/*
FindMaxDistance(root_1);
System.out.println(maxLen);

maxLen=0;*/
FindMaxDistance(root_2);
System.out.println(maxLen);
}

public static Node createTree_1(){
Node root=new Node(1);
Node node=new Node(2);
root.left=node;
node=new Node(3);
root.right=node;

node=new Node(4);
root.left.left=node;
root.left.right=new Node(5);

root.right.left=new Node(6);
root.right.right=new Node(7);

root.left.left.left=new Node(8);
root.right.right.left=new Node(9);

return root;
}

public static Node createTree_2(){
Node root=new Node(1);

Node node=new Node(2);
root.left=node;

node=new Node(3);
root.left.left=node;
root.left.right=new Node(5);

root.left.left.left=new Node(4);
root.left.right.right=new Node(6);

return root;
}

public static void FindMaxDistance(Node root){
if(root==null){
return;
}
if(root.left==null){
root.leftMaxDistance=0;
}
if(root.right==null){
root.rightMaxDistance=0;
}
if(root.left!=null){
FindMaxDistance(root.left);
}
if(root.right!=null){
FindMaxDistance(root.right);
}
if(root.left!=null){
root.leftMaxDistance=max(root.left.leftMaxDistance,root.left.rightMaxDistance)+1;
}
if(root.right!=null){
root.rightMaxDistance=max(root.right.leftMaxDistance,root.right.rightMaxDistance)+1;
}
if(root.leftMaxDistance+root.rightMaxDistance>maxLen){
maxLen=root.leftMaxDistance+root.rightMaxDistance;
}
}

private static int max(int a, int b) {
return a>b?a:b;
}

}

class Node{
int value;
Node left;
Node right;
int leftMaxDistance;
int rightMaxDistance;

public Node(int value){
this.value=value;
this.left=null;
this.right=null;
}
}

方法2

这个问题的核心是，情况A 及 B 需要不同的信息: A 需要子树的最大深度，B 需要子树的最大距离。只要函数能在一个节点同时计算及传回这两个信息（将这2类消息封装到一个类中）；

public class Num11_2 {

public static void main(String[] args) {
Node_2 root_1=createTree_1();
Result res_1=FindMaxDistance(root_1);
System.out.println(res_1.maxDistance+"   "+res_1.maxDepth);

Node_2 root_2=createTree_2();
Result res_2=FindMaxDistance(root_2);
System.out.println(res_2.maxDistance+"   "+res_2.maxDepth);
}

public static Node_2 createTree_1(){
Node_2 root=new Node_2(1);
Node_2 node=new Node_2(2);
root.left=node;
node=new Node_2(3);
root.right=node;

node=new Node_2(4);
root.left.left=node;
root.left.right=new Node_2(5);

root.right.left=new Node_2(6);
root.right.right=new Node_2(7);

root.left.left.left=new Node_2(8);
root.right.right.left=new Node_2(9);

return root;
}

public static Node_2 createTree_2(){
Node_2 root=new Node_2(1);

Node_2 node=new Node_2(2);
root.left=node;

node=new Node_2(3);
root.left.left=node;
root.left.right=new Node_2(5);

root.left.left.left=new Node_2(4);
root.left.right.right=new Node_2(6);

return root;
}

public static Result FindMaxDistance(Node_2 root){
if(root==null){
return new Result(-1,0);
}

Result lhs=FindMaxDistance(root.left);
Result rhs=FindMaxDistance(root.right);

Result res=new Result();
res.maxDepth=max(lhs.maxDepth+1,rhs.maxDepth+1);
res.maxDistance=max(max(lhs.maxDistance,rhs.maxDistance),lhs.maxDepth+rhs.maxDepth+2);

return res;
}

private static int max(int i, int j) {
return i>j?i:j;
}

}
class Node_2{
int value;
Node_2 left;
Node_2 right;

public Node_2(int value){
this.value=value;
this.left=null;
this.right=null;
}
}

class Result{
int maxDepth;
int maxDistance;

public Result(){

}

public Result(int maxDepth,int maxDistance){
this.maxDepth=maxDepth;
this.maxDistance=maxDistance;
}
}