求一颗二叉树上的最远距离(树形DP)

一、题目

　　二叉树中，一个节点可以往上走和往下走，那么从节点A总能走到节点B。

　　节点A走到节点B的距离为:A走到B最短路径上的节点个数。

　　求一颗二叉树上的最远距离

二、思路

　　利用递归分别求出每个节点的左右子树中的最大距离，和该节点的高度。

三、代码实现

public class MaxDistanceInTree {
    
    public static class Node{
        public int value;
        public Node left;
        public Node right;
        
        public Node(int value) {
            this.value = value;
        }
    }
    
    public static class ReturnType{
        public int maxDistance;
        public int h;
        
        public ReturnType(int maxDistance, int h) {
            this.maxDistance = maxDistance;
            this.h = h;
        }
    }
    
    public static ReturnType process(Node head){
        if(head==null){
            return new ReturnType(0, 0);
        }
        ReturnType leftReturnType = process(head.left);
        ReturnType rightReturnType = process(head.right);
        int includeHeadDistance = leftReturnType.h+1+rightReturnType.h;
        int p1 = leftReturnType.maxDistance;
        int p2 = rightReturnType.maxDistance;
        int resDistance = Math.max(Math.max(p1, p2), includeHeadDistance);
        int hitselef = Math.max(leftReturnType.h, rightReturnType.h)+1;//自身高度
        return new ReturnType(resDistance, hitselef);
    }
    
    public static int maxDistance(Node head){
        int [] record = new int[1];
        return posOrder(head, record);
    }
    
    public static int posOrder(Node head,int[] record){
        if(head==null){
            record[0] = 0;
            return 0;
        }
        int lMax = posOrder(head.left, record);
        int maxFromLeft = record[0];
        int rMax = posOrder(head.right, record);
        int maxFromRight = record[0];
        int curNodeMax = maxFromLeft+maxFromRight+1;
        record[0] = Math.max(maxFromLeft, maxFromRight)+1;//当前节点的高度
        return Math.max(Math.max(lMax, rMax), curNodeMax);
    }
    
    public static void main(String[] args) {
        /**
         *                       1
         *                  2           3
         *               4    5      6      7
         *           8                 9
         */
        Node head1 = new Node(1);
        head1.left = new Node(2);
        head1.right = new Node(3);
        head1.left.left = new Node(4);
        head1.left.right = new Node(5);
        head1.right.left = new Node(6);
        head1.right.right = new Node(7);
        head1.left.left.left = new Node(8);
        head1.right.left.right = new Node(9);
        System.out.println(maxDistance(head1));
        
        
        Node head2 = new Node(1);
        head2.left = new Node(2);
        head2.right = new Node(3);
        head2.right.left = new Node(4);
        head2.right.right = new Node(5);
        head2.right.left.left = new Node(6);
        head2.right.right.right = new Node(7);
        head2.right.left.left.left = new Node(8);
        head2.right.right.right.right = new Node(9);
        System.out.println(maxDistance(head2));
    }
}