重建二叉树

1. 题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

2. 解题思路

在二叉树的前序遍历中，第一个数字总是树的根节点。在中序遍历中，树的根节点在序列的中间某个位置，左子树的节点的值位于根节点的左边，右子树节点的值位于根节点值的右边。

在找到了整颗树的根节点后，扫描中序遍历序列找到第一个根结点的位置，由此可以找到左子树的节点的个数和右子树节点的个数，然后在前序遍历序列中找到左子树的根节点，再到中序遍历序列中找到左子树的左子树和右子树。依次递归。

由于二叉树的构造本身就是用递归实现的，所以重建二叉树也用递归进行实现实很简单的。

则重建出下图的二叉树
				                   1
				                 /   \
				                2     3
				               /     / \
				              4     5   6
				               \        /
				               7        8

3. 代码实现

版本一：

public class RebuildingBinaryTree {

	public static void main(String[] args) {
		
	        int[] preOrder={1,2,4,7,3,5,6,8};  //前序遍历序列
	        int[] inOrder={4,7,2,1,5,3,8,6};   // 中序遍历序列
	        BinaryTreeNode node=reConstruct(preOrder,inOrder);
	        printTree(node);
	        
	}
	
	//二叉树节点(静态内部类)
	public static class BinaryTreeNode{
		    int value;
			BinaryTreeNode left;
		    BinaryTreeNode right;
	}
		
	// 判断前序和中序的输入合法性
	public static BinaryTreeNode reConstruct(int[] preOrder,int[] inOrder){
	    if(preOrder==null||inOrder==null||preOrder.length!=inOrder.length||preOrder.length<1){
	    	return null;
	    }
		      
	    return construct(preOrder,0,preOrder.length-1,inOrder,0,inOrder.length-1);
    }
	
	
	/**
     * 根据前序遍历和中序遍历构建二叉树
     * @param preOrder    前序遍历序列
     * @param ps          前序遍历开始位置
     * @param pe          前序遍历结束位置
     * @param inOrder     中序遍历序列
     * @param is          中序遍历开始位置
     * @param ie          中序遍历结束位置
     * @return            构建的树的根节点
     */
	public static BinaryTreeNode construct(int[] preOrder,int ps,int pe,int[] inOrder,int is,int ie){
        
        if(ps>pe)              // 开始位置大于结束位置说明已经处理到叶节点了
            return null;       
        int value=preOrder[ps];  // 前序遍历第一个数字为当前的根节点       
        int index=is;
        while(index<=ie&&inOrder[index]!=value){  //index为根节点在中序遍历序列中的索引
            index++;
        }
        System.out.println("当前各参数的数值为->ps:"+ps+" pe:"+pe+" is："+is+" ie："+ie+" index："+index+" rootValue："+value); 
        
        if(index>ie){           //如果在整个中序遍历中没有找到根节点说明输入的数据是不合法的
            throw new RuntimeException("invalid input"+index);
        }
        
        BinaryTreeNode node=new BinaryTreeNode();
        node.value=value;
        //当前节点的左子树的个数为index-is
        //左子树对应的前序遍历的位置在preOrder[ps+1,ps+index-is]
        //左子树对应的中序遍历的位置在inOrder[is,index-1]
        node.left=construct(preOrder,ps+1,ps+index-is,inOrder,is,index-1);
        //当前节点的右子树的个数为ie-index
        //右子树对应的前序遍历位置在preOrder[ps+index-is+1,pe]
        //右子树对应的中序遍历位置在inOrder[index+1,ie]
        node.right=construct(preOrder,ps+index-is+1,pe,inOrder,index+1,ie);
        return node;
    }
	
    //中序遍历递归打印
    public static void printTree(BinaryTreeNode node){
        if(node!=null){
            printTree(node.left);
            System.out.print(node.value+" ");
            printTree(node.right);
        }
    }
    

}

版本二：

下面只是检查条件没有了，默认给出的前序遍历和中序遍历是正确的。

public class RebuildingBinaryTree {

	public static void main(String[] args) {
		
		int[] pre={1,2,4,7,3,5,6,8};  //前序遍历序列
        int[] in={4,7,2,1,5,3,8,6};   // 中序遍历序列
        
        RebuildingBinaryTree rsb=new RebuildingBinaryTree();
        TreeNode nn=rsb.reConstructBinaryTree(pre,in);
        System.out.println("............................");
        rsb.printTree(nn);
	}

	
	//二叉树节点(静态内部类)
	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);
	        //System.out.println(root.val);
	        return root;
	    }
		
    // 重载方法二：前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
    public  TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,int [] in,int startIn,int endIn) {
    	System.out.println("当前各参数的数值为->startPre:"+startPre+" endPre:"+endPre+" startIn："+startIn+" endIn："+endIn+"\n");
        if(startPre>endPre||startIn>endIn)
            return null;
        TreeNode root=new TreeNode(pre[startPre]);        
        for(int i=startIn;i<=endIn;i++)
            if(in[i]==pre[startPre]){ 
            	System.out.println(".."+"startPre:"+startPre+" i:"+i+" startIn："+startIn+" root:"+root.val);
                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);
                break;
            }
                 
        return root;
    }
    
  //中序遍历递归打印
    public  void printTree(TreeNode node){
        if(node!=null){
            printTree(node.left);
            System.out.print(node.val+" ");
            printTree(node.right);
        }
    }
  

}

运行：

当前各参数的数值为->startPre:0 endPre:7 startIn：0 endIn：7

..startPre:0 i:3 startIn：0 root:1
当前各参数的数值为->startPre:1 endPre:3 startIn：0 endIn：2

..startPre:1 i:2 startIn：0 root:2
当前各参数的数值为->startPre:2 endPre:3 startIn：0 endIn：1

..startPre:2 i:0 startIn：0 root:4
当前各参数的数值为->startPre:3 endPre:2 startIn：0 endIn：-1

当前各参数的数值为->startPre:3 endPre:3 startIn：1 endIn：1

..startPre:3 i:1 startIn：1 root:7
当前各参数的数值为->startPre:4 endPre:3 startIn：1 endIn：0

当前各参数的数值为->startPre:4 endPre:3 startIn：2 endIn：1

当前各参数的数值为->startPre:4 endPre:3 startIn：3 endIn：2

当前各参数的数值为->startPre:4 endPre:7 startIn：4 endIn：7

..startPre:4 i:5 startIn：4 root:3
当前各参数的数值为->startPre:5 endPre:5 startIn：4 endIn：4

..startPre:5 i:4 startIn：4 root:5
当前各参数的数值为->startPre:6 endPre:5 startIn：4 endIn：3

当前各参数的数值为->startPre:6 endPre:5 startIn：5 endIn：4

当前各参数的数值为->startPre:6 endPre:7 startIn：6 endIn：7

..startPre:6 i:7 startIn：6 root:6
当前各参数的数值为->startPre:7 endPre:7 startIn：6 endIn：6

..startPre:7 i:6 startIn：6 root:8
当前各参数的数值为->startPre:8 endPre:7 startIn：6 endIn：5

当前各参数的数值为->startPre:8 endPre:7 startIn：7 endIn：6

当前各参数的数值为->startPre:8 endPre:7 startIn：8 endIn：7

............................
4 7 2 1 5 3 8 6 

以上是参数了各路大神代码后的分析与总结。

参考：

https://www.cnblogs.com/gl-developer/p/6444280.html