书籍二叉树问题

二叉树节点间的最大距离问题

题目：

从二叉树的节点A出发，可以向上或者向喜爱走，但沿途的节点只能经过一次，当到达节点B时，路径上的节点数叫作A到B的距离。

解答：

主要是利用二叉树的遍历，进行处理。

一个以h为头的树上，最大距离只可能来自以下三种情况。

h的左子树上的最大距离

h的右子树上的最大距离

h左子树上离h.left最远的距离+1（h）+h右子树上离h.right最远的距离。

public int maxDistance(Node head){

    int[] record  = new int[1];
    return posOrder(head,record);

}


public 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 Node preIntoTree(int[] pre,int[] in){
    if(pre == null || in == null){
        return null;
    }
    
    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    for(int i = 0;i<in.length;i++){
        map.put(in[i],i);
    }
    return preIn(pre,0,pre.length - 1,in,0,in.length - 1,map);
}

public Node preIn(int[] p,int pi,int pj,int[] n,int ni,int nj,HashMap<Integer,Integer> ,map){

    if(pi>pj){
        return null;
    }
    Node head = new Node(p[pi]);
    int index = map.get(p[pi]);
    head.left = preIn(p,pi+1,pi+index-ni,n,ni,index-1,map);
    head.right = preIn(p,pi+index-ni+1,pj,n,index+1,nj,map);
    return head;
}

中序和后序结合

public Node inPosToTree(int[] in,int[] pos){
    if(in == null || pos == null){
        return null;
    }
    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    for(int i = 0;i < in.length;i++){
        map.put(in[i],i);
    }
    return inPos(in,0,in,length - 1,pos,0,pos.length - 1,map);
}


public Node inPos(int[] n,int ni,int nj,int[] s,int si,int sj,HashMap<Integer,Integer> map)
    if(si>sj){
        return null;
    }
    Node head = new Node[s[sj]];
    int index = map.get(s[sj]);
    head.left = inPos(n,ni,index-1,s,si,si+index-ni-1,map);
    head.right = inPos(n,index+1,nj,s,si+index-ni,sj-1,map);
    return head;

}

先序和后序结合重构二叉树，要求面试者首先分析出节点值都不同的二叉树

public Node prePosToTree(int[] pre,int[] pos){
    if(pre == null || pos == null){
        retrun null;
    }
    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    for(int i = 0;i<pos.length;i++){
        map.put(pos[i],i);
    }
    return prePos(pre,0,pre.length - 1,pos,0,pos.length - 1,map);
}


public Node prePos(int[] p,int pi, int pj,int[] s,int si,int sj,HashMap<Integer,Integer> map ){
    Node head = new Node(s[sj--]);
    if(pi == pj){
        return head;
    }

    int index = map.get(p[++pi]);
    head.left = prePos(p,pi,pi+index-si,s,si,index,map);
    head.right = prePos(p,pi+index-si+1,pj,s,index+1,sj,map);
    return head;
}