算法笔试-树结构

1.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树
假设输入的前序遍历和中序遍历的结果中都不含有重复的数字，例如输入前序遍历{1,2,4,7,3,5,6,8}中序遍历{4,7,2,1,5,3,8,6}重建二叉树并返回。
解题思路：递归回溯

public class TreeNode {
//树结构
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x){ val =x ;}
}

    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root=reConstructBinaryTree(pre, 0, pre.length-1, in, 0, in.length-1);
        return root;
    }
    //前序遍历{1,2,4,7,3,5,6,8} 中序遍历{4,7,2,1,5,3,8,6}
    private TreeNode reConstructBinaryTree(int[] pre,int startPre,int endPre,int[] in,int startIn,int endIn){
        if(startPre>endPre||startIn>endIn) return null;
        //搜索将当前子树root结点放到树中
        TreeNode root=new TreeNode(pre[startPre]);

        for(int i=startIn;i<=endIn;i++){

            if(in[i]==pre[startPre]){
                root.left=reConstructBinaryTree(pre, startPre+1, startPre+i-startIn, in, startIn, i-1);
                root.right=reConstructBinaryTree(pre, i-startIn+startPre+1, endPre, in, i+1, endIn);
            }

        }
        return root;
    }

2.输入一棵树A,B，判断B是不是A的子结构。ps我们约定空树不是任意一个树的子结构

    public boolean HasSubTree(TreeNode root1,TreeNode root2){
        boolean result=false;
        if(root1!=null && root2!=null){
            if(root1.val==root2.val){
            //从根结点开始比较
                result=DoesTree1HaveTree2(root1, root2);
                //写了一个新方法，不能直接去用本方法递归，会涉及到左右子树和该树的比较
            }
            if(!result){
            //若根结点返回false，判断A的左子树和B是否子结构
                result=HasSubTree(root1.left, root2);
            }
            if(!result){
            //若左子树返回false判断右子树和B是否子结构
                result=HasSubTree(root1.right, root2);
            }
        }
        return result;
    }
    public boolean DoesTree1HaveTree2(TreeNode root1,TreeNode root2){
    //该方法判断root2是否root1的子结构
        if(root1==null && root2 !=null) return false;

        if(root2==null) return true;

        if(root1.val!=root2.val) return false;

        //if(roo1.val==root2.val) 
        //return true;这种写法是否正确？？？

        return DoesTree1HaveTree2(root1.left, root2.left) && DoesTree1HaveTree2(root1.right, root2.right);

    }

3.操作给定的二叉树，将其变换成为源二叉树的镜像

    public void Mirror(TreeNode root){

        if(root==null) return;
        //交换左子树右子树的结点
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        //递归左子树和右子树
        Mirror(root.left);
        Mirror(root.right); 

    }

4.输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

public boolean VerifySquenceOfBST(int[] sequence){
        if(sequence.length==0) return false;

        return IsTreeBST(sequence,0,sequence.length-1);
    }
    public boolean IsTreeBST(int[] sequence,int start,int end){
        if(end<=start) return true;
        int i=start;
        for(;i<end;i++){
            if(sequence[i] > sequence[end]) break;
        }
        for(int j=i;j<end;j++){
            if(sequence[j] < sequence[end]) return false;
        }

        return IsTreeBST(sequence,start,i-1) && IsTreeBST(sequence,i,end-1);


    }

5.从上往下打印二叉树的每一个结点，同层结点从左往右打印
解题思路：定义一个队列存放结点

public ArrayList<Integer> printFromTop(TreeNode root){
        ArrayList<Integer> result=new ArrayList<Integer>();
        if(root==null) return result;
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.add(root);

        while(!queue.isEmpty()){
            TreeNode node=queue.poll();//从队列删除第一个元素
            result.add(node.val);
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }

        }
        return result;
    }