计算树中两点之间的距离

今天看到的一个编程题，拿上来仅供大家参考，存在问题的地方，望大家不吝指出！


题目：

要求倒不麻烦，一个节点数据不重复的二叉树，设其元素类型为整型，找出最小元素与最大元素之间的路径长度，即两个节点之间的连线距离，不是节点个数。

过程：

以数组元素来构建二叉树，自定义数组为{2,3,1,8,5,7,4,6}，以（2*i+1,2*i+2）表示子节点，构建树结构如图：



代码：

class TreeNode {//二叉树结构，为了简单起见，直接将属性默认为包可访问
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
public class t{//直接将方法定义为主类中的方法，而不是分为树方法和外部比较、查找方法等工具方法
public static void main(String[] args){
int[] arr=new int[]{2,3,1,8,5,7,4,6};//二叉树基本节点数据
TreeNode root=init_tree(arr,0);//构建二叉树
//show_tree(root);//前序遍历二叉树

List<Integer> max_arr=new ArrayList<Integer>();//从根到最大节点的路径，逆序存储
List<Integer> min_arr=new ArrayList<Integer>();//从根到最小节点的路径，逆序

int max_value=get_value(root,0,true);//从树中找到最大数据节点，只是演示，所以数据类型为整型
int min_value=get_value(root,65536,false);//最小数据节点

get_rout(root,max_arr,max_value);//在max_arr中存储从根到最大节点的路径，可以随便设置两个要查询的点
get_rout(root,min_arr,min_value);//在min_arr中存储从根到最小节点的路径
//不一定非要查询max_value和min_value之间的距离
//get_rout(root,max_arr,3);get_rout(root,min_arr,7); 可以自选两个节点
System.out.println("rout1:"+max_arr);//输出路径
System.out.println("rout2:"+min_arr);//输出路径
System.out.println("dis:"+get_dis(max_arr,min_arr));//输出给出的两个节点之间的距离

}
private static void show_tree(TreeNode root){//前序遍历二叉树
if(root!=null){
System.out.println(root.val);
show_tree(root.left);
show_tree(root.right);
}
}
private static TreeNode init_tree(int[] arr,int i){//利用数组构建二叉树
TreeNode root=null;
if(i<arr.length){
root=new TreeNode(arr[i]);
root.left=init_tree(arr,2*i+1);
root.right=init_tree(arr,2*i+2);
}
return root;
}
private static int get_rout(TreeNode root,List<Integer> arr,int value){//根据输入的value值
int f=0;					//在树中找出一条搜索路径，存入list中
if(root!=null){
if(root.val==value){
arr.add(value);
return 1;
}
f=get_rout(root.left,arr,value);
if(f==1){
arr.add(root.val);
return 1;
}
f=get_rout(root.right,arr,value);
if(f==1){
arr.add(root.val);
return 1;
}
}
return f;
}
private static int get_value(TreeNode root,int value,boolean c){//查找树中的最大值
if(root!=null){						//给出c用于设置比较逻辑
if(compare_logic(root.val,value,c)){
value=root.val;
}
value=get_value(root.left,value,c);
value=get_value(root.right,value,c);
}
return value;
}
private static boolean compare_logic(int n1,int n2,boolean c){//比较逻辑,这里比较对象只是整型数据
//复杂对象也可以自定义比较规则
if(c){ //c 为true，返回 n1 大于n2 的结果
return n1>n2;
}else{ //c 为false，返回 n1 小于n2 的结果
return n1<n2;
}
}
public static int get_dis(List<Integer> arr1,List<Integer> arr2) {
int result=0;//从arr1和arr2两个由根到达指定节点的路径，来去除重复部分（重复路径），返回路径长度
int i=1;
int len=arr1.size()<=arr2.size()?arr1.size():arr2.size();
while(i<=len&&arr1.get(arr1.size()-i)==arr2.get(arr2.size()-i)){
i++;
}
result=arr1.size()-(i-1)+arr2.size()-(i-1);
return result;
}
}

结果：

此时查询的是max_value=8和min_value=1，这两个节点之间的路径长，从图中也可以看出8-3,3-2,2-1，长度为3

rout1:[8, 3, 2]
rout2:[1, 2]
dis:3