剑指Offer面试题6：重建二叉树 Java实现

题目：重建二叉树

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

算法分析：

在二叉树的前序遍历序列中，第一个数字总是树的根节点的值。但在中序遍历中，根节点的值在序列的中间，左子树的结点的值位于根节点的值的左边，而右子树的结点的值位于根节点的右边。因此我们需要扫描中序遍历序列，才能找到根节点的值。

 

如图所示，前序遍历序列的第一个数字1就是根节点的值。扫描中序遍历序列，就能确定根节点的值的位置。根据中序遍历的特点，在根节点的值1前面3个数字都是左子树结点的值，位于1后面的数字都是右子树结点的值。

 

由于中序遍历序列中，有3个数字是左子树结点的值，因此左子树总共有3个左子结点。同样，在前序遍历的序列中，根节点后面的3个数字就是3个左子树结点的值，再后面的所有数字都是右子树结点的值。这样我们就在前序遍历和中序遍历两个序列中，分别找到了左右子树对应的子序列。

 

 

既然我们已经分别找到了左、右子树的前序遍历序列和中序遍历序列，我们可以用同样的方法分别去构建左右子树。也就是说，接下来的事情可以用递归的方法去完成。

算法源程序；

   
   
/**************************************************************      
* Copyright (c) 2016, 北京邮电大学          
* All rights reserved.                   
* 版 本 号：v1.0                   
* 题目描述：重建二叉树
*		       输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复数字。
*		       例如，输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出图中所示的二叉树并输出它的头节点。
* 输入描述：无
* 程序输出：  4 7 2 1 5 3 8 6 Exception in thread "main" 
*			5 4 3 2 1 
*			1 2 3 4 5 
*			1 
*			4 2 5 1 6 3 7 
* 问题分析：无
* 算法描述：无
* 完成时间：2016-10-30
***************************************************************/
package org.marsguo.offerproject06;
/*
定义二叉树节点
*/
class TreeNode{
	int val;
	public TreeNode left = null;
	public TreeNode right = null;
}
class SolutionMethod1{
	/** 
     * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二节树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 
     * 
     * @param preorder 前序遍历 
     * @param inorder  中序遍历 
     * @return 树的根结点 
     */  
	public TreeNode BinaryTreeFunction(int[] preorder,int[] inorder){
		if(preorder == null || inorder == null || 
				preorder.length != inorder.length || inorder.length < 1){
			return null;
		}
		
		return ConstructCore(preorder,0,preorder.length - 1,inorder,0,inorder.length - 1);
	}
	
	/** 
     * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二节树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 
     * 
     * @param preorder 前序遍历 
     * @param ps       前序遍历的开始位置 
     * @param pe       前序遍历的结束位置 
     * @param inorder  中序遍历 
     * @param is       中序遍历的开始位置 
     * @param ie       中序遍历的结束位置 
     * @return 树的根结点 
     */ 
	public TreeNode ConstructCore(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++;
		}
		
		if(index > ie){										// 如果在整个中序遍历的数组中没有找到，说明输入的参数是不合法的，抛出异常  
			throw new RuntimeException("Invalid input");
		}
		
		TreeNode node = new TreeNode();						// 创建当前的根结点，并且为结点赋值  
		node.val = value;
		
		/*
		 递归构建当前根结点的左子树，左子树的元素个数：index-is+1个  
                  左子树对应的前序遍历的位置在[ps+1, ps+index-is]  
                  左子树对应的中序遍历的位置在[is, index-1]  
         */
        node.left = ConstructCore(preorder, ps + 1, ps + index - is, inorder, is, index - 1); 
        
        /*递归构建当前根结点的右子树，右子树的元素个数：ie-index个  
         	右子树对应的前序遍历的位置在[ps+index-is+1, pe]  
         	右子树对应的中序遍历的位置在[index+1, ie] 
          */
        node.right = ConstructCore(preorder, ps + index - is + 1, pe, inorder, index + 1, ie);  
  
        // 返回创建的根结点  
        return node;  
	}
	
	public void printTree(TreeNode root){			// 中序遍历二叉树  
		if(root != null){
			printTree(root.left);
			System.out.print(root.val + " ");
			printTree(root.right);
		}
		//System.out.println();
	}
	
	// 普通二叉树  
    //              1  
    //           /     \  
    //          2       3  
    //         /       / \  
    //        4       5   6  
    //         \         /  
    //          7       8  
    public  void test1() {  
        int[] preorder = {1, 2, 4, 7, 3, 5, 6, 8};  
        int[] inorder = {4, 7, 2, 1, 5, 3, 8, 6};  
        TreeNode root = BinaryTreeFunction(preorder, inorder);  
        printTree(root);  
    }  
  
    // 所有结点都没有右子结点  
    //            1  
    //           /  
    //          2  
    //         /  
    //        3  
    //       /  
    //      4  
    //     /  
    //    5  
    public  void test2() {  
        int[] preorder = {1, 2, 3, 4, 5};  
        int[] inorder = {5, 4, 3, 2, 1};  
        TreeNode root = BinaryTreeFunction(preorder, inorder);  
        printTree(root);  
    }  
  
    // 所有结点都没有左子结点  
    //            1  
    //             \  
    //              2  
    //               \  
    //                3  
    //                 \  
    //                  4  
    //                   \  
    //                    5  
    public void test3() {  
        int[] preorder = {1, 2, 3, 4, 5};  
        int[] inorder = {1, 2, 3, 4, 5};  
        TreeNode root = BinaryTreeFunction(preorder, inorder);  
        printTree(root);  
    }  
  
    // 树中只有一个结点  
    public void test4() {  
        int[] preorder = {1};  
        int[] inorder = {1};  
        TreeNode root = BinaryTreeFunction(preorder, inorder);  
        printTree(root);  
    }  
  
    // 完全二叉树  
    //              1  
    //           /     \  
    //          2       3  
    //         / \     / \  
    //        4   5   6   7  
    public void test5() {  
        int[] preorder = {1, 2, 4, 5, 3, 6, 7};  
        int[] inorder = {4, 2, 5, 1, 6, 3, 7};  
        TreeNode root = BinaryTreeFunction(preorder, inorder);  
        printTree(root);  
    }  
  
    // 输入空指针  
    public void test6() {  
        BinaryTreeFunction(null, null);  
    }  
  
    // 输入的两个序列不匹配  
   public void test7() {  
        int[] preorder = {1, 2, 4, 5, 3, 6, 7};  
        int[] inorder = {4, 2, 8, 1, 6, 3, 7};  
        TreeNode root = BinaryTreeFunction(preorder, inorder);  
        printTree(root);  
    }  
}
public class RebuildBinaryTree {
	public static void main(String[] args){
		SolutionMethod1 solution1 = new SolutionMethod1();
		solution1.test1();
		System.out.println();
		solution1.test2();
		System.out.println();
		solution1.test3();
		System.out.println();
		solution1.test4();
		System.out.println();
		solution1.test5();
		System.out.println();
		solution1.test6();
		System.out.println();
		solution1.test7();
		System.out.println();
	}
}

程序运行结果