二叉树的基本操作，遍历，子结构，镜像，构建

总结了二叉树的一些基本操作，包括

• 1）判断给定两个序列，一个作为前序，一个作为中序，是否可以构成一棵二叉树，测试用例：前序：{1,2,4,7,3,10,6,8}中序： {4,7,2,1,10,3,8,6} —-public BinaryTreeNode ConstructCore(int[] Preorder,int[] Inorder,int startPreorder,int endPreorder,int startInorder,int endInorder)；
  
• 2）树的前序递归遍历—public void printfBinaryTree(BinaryTreeNode node)；
• 3）树的非递归前序遍历—public void printfBinaryTreeNotRecurision(BinaryTreeNode node)；
• 4）树的中序递归遍历—printfBinaryTreeByInOrder(BinaryTreeNode node)；
• 5）树的非递归中序遍历—public void printfBinaryTreeInOrderNotRecurision(BinaryTreeNode node)；
• 6）树的后序递归遍历—public void printfBinaryTreeLastOrder(BinaryTreeNode node)；
• 7）树的非递归后序遍历—public void printfBinaryTreeLastOrderNotRecurision(BinaryTreeNode node)；
• 8）树的层次遍历—-public void printfBinaryFromTopToBottom(BinaryTreeNode node)
• 9）查找树的子结构—boolean HasSubTree(BinaryTreeNode treeA,BinaryTreeNode treeB)；
• 10）打印树的镜像—public void MirrorRecursively(BinaryTreeNode tree)
• 11）判断指定序列是否是一个二叉排序树的后序遍历—public boolean verfiySequenceOfBST(int[] sequence)；
• 12）查找二叉树的路径和与给定值相等的路径—FindPath(BinaryTreeNode pRoot,int expectedSum)；

package findKeyInArray;import java.util.Arrays;import java.util.Queue;import java.util.Stack;import java.util.Vector;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;class BinaryTreeNode{    int m_value;    BinaryTreeNode m_pLeft;    BinaryTreeNode m_pRight;    public BinaryTreeNode(int value){        m_value = value;    }}public class ConstructBinaryTree {    BinaryTreeNode root = null;    final int FILE_QUEUE_SIZE = 100;// 阻塞队列大小      //前序遍历打印树节点；采用递归算法    public void printfBinaryTree(BinaryTreeNode node){        System.out.print(node.m_value+" ");        if(node.m_pLeft != null){            printfBinaryTree(node.m_pLeft);        }        if(node.m_pRight != null){            printfBinaryTree(node.m_pRight);        }    }    //前序遍历采用非递归树    public void printfBinaryTreeNotRecurision(BinaryTreeNode node){        if(node==null) return;        //System.out.print(node.m_value+" ");        Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();//建立一个栈        BinaryTreeNode p = node;        while(!s.isEmpty() || p!=null ){            if(p!=null){                System.out.print(p.m_value+" ");                s.push(p);                p = p.m_pLeft;            }else{                p = s.peek();                s.pop();                p = p.m_pRight;            }        }    }    //中序遍历打印树节点；    public void printfBinaryTreeByInOrder(BinaryTreeNode node){                     if(node.m_pLeft != null){            printfBinaryTreeByInOrder(node.m_pLeft);        }        System.out.print(node.m_value+" ");        if(node.m_pRight != null){            printfBinaryTreeByInOrder(node.m_pRight);        }    }    //中序遍历采用非递归树        public void printfBinaryTreeInOrderNotRecurision(BinaryTreeNode node){            if(node==null) return;            //System.out.print(node.m_value+" ");            Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();//建立一个栈            BinaryTreeNode p = node;            while(!s.isEmpty() || p!=null ){                if(p!=null){                    s.push(p);                    p = p.m_pLeft;                }else{                    p = s.peek();                    System.out.print(p.m_value+" ");                    s.pop();                    p = p.m_pRight;                }            }        }    //后序遍历，采用递归    public void printfBinaryTreeLastOrder(BinaryTreeNode node){        if(node==null) return;        if(node.m_pLeft!=null){            printfBinaryTreeLastOrder(node.m_pLeft);        }        if(node.m_pRight!=null){            printfBinaryTreeLastOrder(node.m_pRight);        }        System.out.print(node.m_value+" ");    }    //后序遍历采用非递归树        public void printfBinaryTreeLastOrderNotRecurision(BinaryTreeNode node){            if(node==null) return;            //System.out.print(node.m_value+" ");            Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();//建立一个栈            BinaryTreeNode p = node;            BinaryTreeNode r=null;            while(!s.isEmpty() || p!=null ){                if(p!=null){                    //System.out.print(p.m_value+" ");                    s.push(p);                    p = p.m_pLeft;                }else{                    //当左子树为空的时候，查看当前节点有没有右子树                    //左子树为空，并且右子树为空，则当前是叶子节点；                    //如果左子树为空，右子树不为空，则当前节点是有右子树的根节点，此时应该打印当前节点的右子树节点。                    p = s.peek();                    if(p.m_pRight!=null && p.m_pRight!=r){                        //如果p有右子树                        p = p.m_pRight;                        //System.out.println(p);                    }else{                        //当前节点就是叶子节点                        System.out.print(p.m_value+" ");                        s.pop();                        r=p;                        p = null;                    }                }            }        }    //层次遍历树节点    public void printfBinaryFromTopToBottom(BinaryTreeNode node){        if(node==null){            return;        }        BlockingQueue<BinaryTreeNode> queue = new ArrayBlockingQueue<BinaryTreeNode>(FILE_QUEUE_SIZE);        queue.add(node);        while(queue.size()!=0){            BinaryTreeNode pNode = queue.peek();            queue.remove();            System.out.print(pNode.m_value+" ");            if(pNode.m_pLeft!=null){                queue.add(pNode.m_pLeft);            }            if(pNode.m_pRight!=null){                queue.add(pNode.m_pRight);            }        }    }    //递归构建树    public BinaryTreeNode ConstructCore(int[] Preorder,int[] Inorder,int startPreorder,int endPreorder,int startInorder,int endInorder){        int rootValue = Preorder[startPreorder];        BinaryTreeNode root = new BinaryTreeNode(rootValue);        root.m_pRight = root.m_pLeft = null;        if(startPreorder == endPreorder){            if(startInorder == endInorder) return root;            else {                System.out.println("无效的输入");                return null;            }        }        //在中序中找到根节点        int rootInorder = startInorder;        while(rootInorder <= endInorder && Inorder[rootInorder] != rootValue){            ++rootInorder;        }        if(rootInorder == endInorder && Inorder[rootInorder] != rootValue){            System.out.println("无效的输入");            return null;        }        int leftLength = rootInorder-startInorder;        int leftPreorderEnd = startPreorder+leftLength;        if(leftLength>0){            //构建左子树            root.m_pLeft = ConstructCore(Preorder,Inorder,startPreorder+1,leftPreorderEnd,startInorder,rootInorder-1);        }        if(leftLength<endPreorder-startPreorder){            root.m_pRight = ConstructCore(Preorder,Inorder,leftPreorderEnd+1,endPreorder,rootInorder+1,endInorder);        }        return root;    }    //查找树的子结构    boolean HasSubTree(BinaryTreeNode treeA,BinaryTreeNode treeB){        boolean result = false;        if(treeA!=null &&treeB!=null){            if(treeA.m_value == treeB.m_value){                result = DoesTree1HaveTree2(treeA,treeB);            }            if(!result){                result = HasSubTree(treeA.m_pLeft,treeB);            }            if(!result){                result = HasSubTree(treeA.m_pRight,treeB);            }        }        return result;    }    //打印树的镜像    public void MirrorRecursively(BinaryTreeNode tree){        if(tree == null ) return;        if(tree.m_pLeft ==null|| tree.m_pRight ==null) return;        BinaryTreeNode temp = new BinaryTreeNode(0);        int tempNode = tree.m_pLeft.m_value;        tree.m_pLeft.m_value = tree.m_pRight.m_value;        tree.m_pRight.m_value = tempNode;        if(tree.m_pLeft!=null){            MirrorRecursively(tree.m_pLeft);        }        if(tree.m_pRight!=null){            MirrorRecursively(tree.m_pRight);        }    }    boolean DoesTree1HaveTree2(BinaryTreeNode treeA,BinaryTreeNode treeB){        if(treeB ==null){            return true;        }        if(treeA ==null){            return false;        }        if(treeA.m_value !=treeB.m_value){            return false;        }        return DoesTree1HaveTree2(treeA.m_pLeft,treeB.m_pLeft) &&DoesTree1HaveTree2(treeA.m_pRight,treeB.m_pRight);    }    //面试题24 二叉搜索树的后序遍历序列    public boolean verfiySequenceOfBST(int[] sequence){        if(sequence==null||sequence.length==0)            return false;            int length=sequence.length;            int root=sequence[length-1];            int cut=0;        for(int i=0;i<length-1;i++){            if(sequence[i]>root){                cut=i;                break;            }        }        if(cut==0){            verfiySequenceOfBST(Arrays.copyOfRange(sequence, 0,length-1));        }else{            for(int j=cut;j<length-1;j++){                if(sequence[j]<root)                    return false;            }        }        boolean left=true;        if(cut>0)            left= verfiySequenceOfBST(Arrays.copyOfRange(sequence,0, cut));        boolean right=true;        if(cut<length-1)            right=verfiySequenceOfBST(Arrays.copyOfRange(sequence,cut,length-1));        return (right&&left);    }    //求二叉树中和为某一值的路径    void FindPath(BinaryTreeNode pRoot,int expectedSum){        if(pRoot==null) return;        Vector<Integer> path = new Vector<Integer>();        int currentSum = 0;        FindPath(pRoot,expectedSum,path,currentSum);    }    void FindPath(BinaryTreeNode pRoot,int expectedSum,Vector<Integer> path,int currentSum){        currentSum+=pRoot.m_value;        path.add(pRoot.m_value);        //若为叶结点，并且路劲上结点的和等于输入的值        //打印出这条路劲        boolean isLeft = pRoot.m_pLeft == null && pRoot.m_pRight == null;        if(currentSum == expectedSum && isLeft){            System.out.println("A Path is found：");            //Integer value = null;            int size = path.size();            for (int i=0; i<size; i++) {                System.out.print((Integer)path.get(i)+" ");                                 }            System.out.println();        }        //如果不是叶子节点，则遍历它的子节点        if(pRoot.m_pLeft!=null)            FindPath(pRoot.m_pLeft,expectedSum,path,currentSum);        if(pRoot.m_pRight!=null){            FindPath(pRoot.m_pRight,expectedSum,path,currentSum);        }        //在返回父结点之前，在路径上删除当前结点        path.remove(path.size()-1);    }    public static void main(String[] args) {        // TODO Auto-generated method stub        ConstructBinaryTree binaryTree = new ConstructBinaryTree();        ConstructBinaryTree binaryTree2 = new ConstructBinaryTree();        //根据前序和中序构建树，注意：序列中不能有重复的数据，如果不能构成，则输出无效输入        int[] Preorder1={1,2,4,7,3,10,6,8};//给定树的前序        int[] Inorder1 = {4,7,2,1,10,3,8,6};//给定树的中序        int[] Preorder2={3,5,6,8};        int[] Inorder2 = {5,3,8,6};        binaryTree.root = binaryTree.ConstructCore(Preorder1,Inorder1,0,7,0,7);        binaryTree2.root = binaryTree.ConstructCore(Preorder2,Inorder2,0,3,0,3);        System.out.println("层次遍历");        binaryTree.printfBinaryFromTopToBottom(binaryTree.root);        System.out.println();        System.out.println("前序遍历");        binaryTree.printfBinaryTree(binaryTree.root);        System.out.println();        System.out.println("中序遍历");        binaryTree.printfBinaryTreeByInOrder(binaryTree.root);        System.out.println();        System.out.println("树的非递归前序遍历");        binaryTree.printfBinaryTreeNotRecurision(binaryTree.root);        System.out.println();        System.out.println("树的非递归中序遍历");        binaryTree.printfBinaryTreeInOrderNotRecurision(binaryTree.root);        System.out.println();        System.out.println("树的递归后序遍历");        binaryTree.printfBinaryTreeLastOrder(binaryTree.root);        System.out.println();        System.out.println("树的非递归后序遍历");        binaryTree.printfBinaryTreeLastOrderNotRecurision(binaryTree.root);        System.out.println();        System.out.println("----------------------------------");        System.out.println("判断二叉树是否有子结构");        binaryTree.printfBinaryTree(binaryTree2.root);        boolean result = false;        result=binaryTree.HasSubTree(binaryTree.root, binaryTree2.root);        System.out.println("result:"+result);        System.out.println("二叉树的镜像");        binaryTree2.MirrorRecursively(binaryTree2.root);        System.out.println("二叉树的镜像后的前序输出");        binaryTree2.printfBinaryTree(binaryTree2.root);        System.out.println();        System.out.println("判断指定序列是否是一个二叉排序树的后序遍历");        int[] array={5,7,6,9,11,10,8};        result = binaryTree.verfiySequenceOfBST(array);        System.out.println("result"+result);        System.out.println("查找二叉树的路径和与给定值相等的路径");        binaryTree.FindPath(binaryTree.root, 14);    }}