通过前(后)序遍历和中序遍历构造二叉树

前序遍历和中序遍历构造二叉树

说明

preOrder为前序遍历数组，inOrder为中序遍历数组

    /*preOrder为前序遍历，inOrder为中序遍历
      start：指向inOrder首元素下标
      end：指向inOrder尾元素下标
      preStart：指向preOrder的首元素下标
     */
    public TreeNode createTree(int[] preOrder, int[] inOrder, int start, int end, int preStart) {
        if (start > end)
            return null;
        int k = start;
        //找到在inOrder中和preOrder第一个元素值相等的元素下标k,即找到左右子树的根
        while (inOrder[k] != preOrder[preStart])
            k++;
        //创建根节点
        TreeNode node = new TreeNode(preOrder[preStart]);
        //创建左子树
        node.left = createTree(preOrder, inOrder, start, k - 1, preStart + 1);
        //创建右子树
        node.right = createTree(preOrder, inOrder, k + 1, end, preStart + (k - start + 1));
        //返回根节点
        return node;
    }

算法改进

为了提升 k(中序遍历根结点的下标) 的查询效率，我们借助一个哈希表 HashMap 来存储数组 inOrder 中元素到索引的映射。

1. 优点：时间复杂度降低
2. 缺点：空间复杂度增高

    /*preOrder为前序遍历，inOrder为中序遍历
      start：指向inOrder首元素下标
      end：指向inOrder尾元素下标
      preStart：指向preOrder的首元素下标
     */
    public TreeNode dfs(int[] preOrder, Map<Integer, Integer> inOrderMap, int start, int end, int preStart) {
        if (start > end)
            return null;
        //找到在inOrder中和preOrder第一个元素值相等的元素下标k,即找到左右子树的根
        int k = inOrderMap.get(preOrder[preStart]);
        //创建根节点
        TreeNode node = new TreeNode(preOrder[preStart]);
        //创建左子树
        node.left = dfs(preOrder, inOrderMap, start, k - 1, preStart + 1);
        //创建右子树
        node.right = dfs(preOrder, inOrderMap, k + 1, end, preStart + (k - start + 1));
        //返回根节点
        return node;
    }

    public TreeNode createTree(int[] preOrder, int[] inOrder) {
        //借助哈希表 HashMap 来存储数组 inOrder 中元素到索引的映射。
        //以 inOrder 中的元素作为键，下标作为值
        Map<Integer, Integer> inOrderMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < inOrder.length; i++) {
            inOrderMap.put(inOrder[i], i);
        }
        TreeNode root = dfs(preOrder, inOrderMap, 0, inOrder.length - 1, 0);
        return root;
    }

后序遍历和中序遍历构造二叉树

说明

postOrder为后序遍历数组，inOrder为中序遍历数组

    /*postOrder为后序遍历，inOrder为中序遍历
      start：指向inOrder首元素下标
      end：指向inOrder尾元素下标
      postEnd：指向postOrder的尾元素下标
     */
    public TreeNode createTree(int[] postOrder, int[] inOrder, int start, int end, int postEnd) {
        if (start > end)
            return null;
        int k = start;
        //找到在inOrder中和postOrder最后一个元素值相等的元素下标k,即找到左右子树的根
        while (inOrder[k] != postOrder[postEnd])
            k++;
        //创建根节点
        TreeNode node = new TreeNode(postOrder[postEnd]);
        //创建左子树
        node.left = createTree(postOrder, inOrder, start, k - 1, postEnd - (end - k + 1));
        //创建右子树
        node.right = createTree(postOrder, inOrder, k + 1, end, postEnd - 1);
        //返回根节点
        return node;
    }

算法改进

为了提升 k(中序遍历根结点的下标) 的查询效率，我们借助一个哈希表 HashMap 来存储数组 inOrder 中元素到索引的映射。

1. 优点：时间复杂度降低
2. 缺点：空间复杂度增高

    /*postOrder为后序遍历，inOrder为中序遍历
      start：指向inOrder首元素下标
      end：指向inOrder尾元素下标
      postEnd：指向postOrder的尾元素下标
     */
    public TreeNode dfs(int[] postOrder, Map<Integer, Integer> inOrderMap, int start, int end, int postEnd) {
        if (start > end)
            return null;
        //找到在inOrder中和postOrder最后一个元素值相等的元素下标k,即找到左右子树的根
        int k = inOrderMap.get(postOrder[postEnd]);
        //创建根节点
        TreeNode node = new TreeNode(postOrder[postEnd]);
        //创建左子树
        node.left = dfs(postOrder, inOrderMap, start, k - 1, postEnd - (end - k + 1));
        //创建右子树
        node.right = dfs(postOrder, inOrderMap, k + 1, end, postEnd - 1);
        //返回根节点
        return node;
    }

    public TreeNode createTree(int[] postOrder, int[] inOrder) {
        //借助哈希表 HashMap 来存储数组 inOrder 中元素到索引的映射。
        //以 inOrder 中的元素作为键，下标作为值
        Map<Integer, Integer> inOrderMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < inOrder.length; i++) {
            inOrderMap.put(inOrder[i], i);
        }
        TreeNode root = dfs(postOrder, inOrderMap, 0, inOrder.length - 1, postOrder.length - 1);
        return root;
    }