面试题：根据一颗树的前序遍历与中序遍历构造二叉树

一）题目简介

二）题目分析

1）前序遍历结果中，第一个元素一定是根节点。

2）从中序遍历结果中，先找到根节点的下标值，小于根节点下标的值，一定是根节点的左孩子，大于根节点下标的值，一定是根节点的右孩子。再把中序遍历的结果，分成两组，一个是根节点左孩子组，一个是根节点右孩子组。

3）从头扫描前序遍历，根据中序遍历的分组依次判断该值需要放置到哪一个节点上。

三）题目源码

第一步：初始化二叉树结构

public class StructureBinaryTree {
	
    /** 二叉树结构 */
    static class TreeNode {
        TreeNode left;
        TreeNode right;
        int value;
		
        TreeNode (TreeNode left, TreeNode right, int value) {
            this.left = left;
            this.right = right;
            this.value = value;
        }
    }
}

 

第二步：二分查找法（辅助方法），查找节点下标对应的值

/**
 * 二分查找法, 获取根节点下标的值
 * @return
 */
private int getRootIndex(int[] inorder, int value, int startIndex, int endIndex) {
    if (inorder == null) {
        return -1;
    }
		
    int low = startIndex;
    int high = endIndex;
		
    while (low < high) {
        int min = (low+high) >>> 1; // 得到左中位数,推荐写法
			
        if (inorder[min] < value) {
            low = min+1;
        } else if (inorder[min] > value) {
            high = min-1;
        } else {
            return min;
        }
    }
    return -1;
}

 

第三步：根据一颗树的前序遍历与中序遍历构造二叉树

方式一：通过不断创建新的组，依次扫描判断。(性能耗费多一些)

/**
 * 方式一
 * @param preorder
 * @param inorder
 * @return
 */
public TreeNode buildTreeArray(int[] preorder, int[] inorder) {
    if (preorder == null || inorder == null) {
        return null;
    }
    // 获取长度
    int preLength = preorder.length;
    int inLength = inorder.length;
    if (preLength == 0 || inLength == 0) {
        return null;
    }
		
    // 根节点的值
    int rootValue = preorder[0]; // 前序遍历结果中, 第一个值一定是根节点
		
    // 找出根节点的下标, 由于中序遍历的结果是有序的, 所以可以通过“二分查找法”查找根节点下标的值
    int rootIndex = getRootIndex(inorder, rootValue, 0, inLength);
		
    // 创建节点
    TreeNode treeNode = new TreeNode(null, null, rootValue);
		
    // 小于根节点下标的值,都是根节点的左孩子,大于根节点下标的值,都是根节点的右孩子
    for (int i=0; i < preLength; i++) {
        if (preorder[i] == rootValue) {
            // 往左边添加节点
            treeNode.left = buildTreeArray(Arrays.copyOfRange(preorder, (i + 1), preLength), Arrays.copyOfRange(inorder, i, rootIndex));
				
            // 往右边添加节点
            treeNode.right = buildTreeArray(Arrays.copyOfRange(preorder, (i + 1 + rootIndex), preLength), Arrays.copyOfRange(inorder, (rootIndex + 1), inLength));
            break;
        }
    }
		
    // 返回
    return treeNode;
}

 

方式二：根据数组的下标值，通过不断变化下标值，比较判断。

/**
 * 方式二
 * @param preorder
 * @param inorder
 * @return
 */
public TreeNode buildTreeIndex(int[] preorder, int[] inorder) {
    if (preorder == null || inorder == null) {
        return null;
    }
    return getBinaryTree(0, 0, inorder.length-1, preorder, inorder);
}
	
private TreeNode getBinaryTree(int preIndex, int inIndex, int inEndIndex, int[] preorder, int[] inorder) {
    if (preIndex > preorder.length - 1 || inIndex > inEndIndex) {
        return null;
    }
    // 根节点的值
    int rootValue = preorder[preIndex]; // 由于是前序遍历,第一个值一定是根节点的值
		
    // 找出根节点的下标,由于中序遍历的结果是有序的,所以可以通过“二分搜索法”查找下标的值
    int rootIndex = getRootIndex(inorder, rootValue, inIndex, inEndIndex+1);
		
    // 创建根节点
    TreeNode treeNode = new TreeNode(null, null, rootValue);
    treeNode.left = getBinaryTree(preIndex + 1, inIndex, rootIndex - 1, preorder, inorder);
    treeNode.right = getBinaryTree(preIndex + rootIndex + 1 - inIndex, rootIndex + 1, inEndIndex, preorder, inorder);
        
    // 返回
    return treeNode;
}

 

第四步：二叉树遍历方式（辅助方法）

/**
 * 前序遍历
 * @param tree
 */
public void preTreeNode(TreeNode treeNode) {
    if (treeNode != null) {
        System.out.print(treeNode.value + "\t");
			
        preTreeNode(treeNode.left);
			
        preTreeNode(treeNode.right);
    }
}
	
/**
 * 中序遍历
 * @param tree
 */
public void inTreeNode(TreeNode treeNode) {
    if (treeNode != null) {
        inTreeNode(treeNode.left);
			
        System.out.print(treeNode.value + "\t");
			
        inTreeNode(treeNode.right);
    }
}
	
/**
 * 后序遍历
 * @param tree
 */
public void nextTreeNode(TreeNode treeNode) {
    if (treeNode != null) {
        nextTreeNode(treeNode.left);
			
        nextTreeNode(treeNode.right);
			
        System.out.print(treeNode.value + "\t");
    }
}

 

第五步：main方法测试

public static void main(String[] args) {
    int[] preorder = {28, 16, 13, 22, 30, 29, 43}; // 前序遍历
    int[] inorder = {13, 16, 22, 28, 29, 30, 43};  // 中序遍历
		
    // 初始化
    StructureBinaryTree binary = new StructureBinaryTree();
		
    // 方式一
    TreeNode arrayTreeNode = binary.buildTreeArray(preorder, inorder);
    System.out.println("方式一:");
    System.out.println("前序遍历结果为:");
    binary.preTreeNode(arrayTreeNode);
		
    System.out.println("\n中序遍历结果为:");
    binary.inTreeNode(arrayTreeNode);
		
    System.out.println("\n后序遍历结果为:");
    binary.nextTreeNode(arrayTreeNode);
		
    System.out.println("\n\n-----------------------分割线-----------------------\n");
		
    // 方式二
    TreeNode indexTreeNode = binary.buildTreeIndex(preorder, inorder);
    System.out.println("方式二:");
    System.out.println("前序遍历结果为:");
    binary.preTreeNode(indexTreeNode);
		
    System.out.println("\n中序遍历结果为:");
    binary.inTreeNode(indexTreeNode);
		
    System.out.println("\n后序遍历结果为:");
    binary.nextTreeNode(indexTreeNode);
}

打印效果图：

 

识别二维码关注个人微信公众号

本章完结，待续，欢迎转载！
 
本文说明：该文章属于原创，如需转载，请标明文章转载来源！