微软100题，39题

39.（树、图、算法）
网易有道笔试：
(1).
求一个二叉树中任意两个节点间的最大距离，
两个节点的距离的定义是 这两个节点间边的个数，
比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度。

(2).
求一个有向连通图的割点，割点的定义是，如果除去此节点和与其相关的边，
有向图不再连通，描述算法。

import java.util.Random;

/**
 * <p>File：Test_39_1.java</p>
 * <p>Title: </p>
 * @version 1.0
 * 39.（树、图、算法）
网易有道笔试：
(1).
求一个二叉树中任意两个节点间的最大距离，
两个节点的距离的定义是 这两个节点间边的个数，
比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度。

 */
public class Test_39_1
{
    private static Node root;
    
    private static class Node
    {
        private Node parent;

        private Node left;

        private Node right;
        
        private int depth;
        
        
        public Node(){}
        
        public Node(Node parent, Node left, Node right)
        {
            super();
            this.parent = parent;
            this.left = left;
            this.right = right;
        }

        public int getDepth()
        {
            return depth;
        }

        public void setDepth(int depth)
        {
            this.depth = depth;
        }

        public Node getParent()
        {
            return parent;
        }

        public void setParent(Node parent)
        {
            this.parent = parent;
        }

        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;
        }
    }

    private static void buildBinaryTree()
    {
        Node left=new Node();
        Node right=new Node();
        root=new Node(null,left,right);
        root.setDepth(0);
        left.setParent(root);
        right.setParent(root);
        left.setDepth(1);
        right.setDepth(1);
        buildNode(left);
        buildNode(right);
    }
    
    private static void buildNode(Node node){
        if(node.depth>10){
            return;
        }
        Node left=new Node();
        Node right=new Node();
        left.setDepth(node.getDepth()+1);
        right.setDepth(node.getDepth()+1);
        left.setParent(node);
        right.setParent(node);
        node.setLeft(left);
        node.setRight(right);
        buildNode(node.getLeft());
        buildNode(node.getRight());
    }
    
    private static Node getRandomNode(){
        Random random=new Random();
        Node result=root;
        Random depthR=new Random();
        int d=depthR.nextInt(10);
        for(int i=0;i<d;i++){
            boolean lr=random.nextBoolean();
            if(lr){
                result=result.getLeft();
            }else{
                result=result.getRight();
            }
        }
        return result;
    }
    
    private static void printTree(){
        System.out.println("--0");
        printNode(root.getLeft());
        printNode(root.getRight());
        
    }
    
    private static void printNode(Node node){
        if(node==null){
            return;
        }
        String str="";
        for(int i=0;i<node.getDepth()*2;i++){
            str+="--";
        }
        System.out.println(str+node.depth);
        printNode(node.getLeft());
        printNode(node.getRight());
    }
    
    private static int computeDistance(Node a,Node b){
        if(a==b){
            return 0;
        }
        if(a.depth==b.depth&&a.parent==b.parent){
            return 2;
        }else if(a.depth==b.depth){
            return computeDistance(a.parent,b.parent)+2;  
        }else{
            if(a.depth>b.depth){
                return computeDistance(a.parent,b)+1;
            }else{
                return computeDistance(a,b.parent)+1;
            }
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        buildBinaryTree();
        printTree();
        Node a=getRandomNode();
        Node b=getRandomNode();
        System.out.println("a.深度:"+a.getDepth()+","+"b的深度:"+b.getDepth()+",两节点的长度是:"+computeDistance(a,b));
    }
}