interview/16-LeetCode Hot 100/从前序与中序遍历序列构造二叉树.md

# 从前序与中序遍历序列构造二叉树

LeetCode 105. 中等

## 题目描述

给定两个整数数组 `preorder` 和 `inorder`，其中 `preorder` 是二叉树的先序遍历，`inorder` 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

**示例 1:**
```
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
```

**示例 2:**
```
输入: preorder = [-1], inorder = [-1]
输出: [-1]
```

**限制**:
- `1 <= preorder.length <= 3000`
- `inorder.length == preorder.length`
- `-3000 <= preorder[i], inorder[i] <= 3000`
- `preorder` 和 `inorder` 均无重复元素
- `inorder` 保证是二叉树的中序遍历序列
- `preorder` 保证是同一棵二叉树的前序遍历序列

## 思路推导

### 理解前序和中序遍历

**前序遍历顺序**: 根 → 左 → 右
**中序遍历顺序**: 左 → 根 → 右

```
        3
       / \
      9  20
        /  \
       15   7

前序遍历: [3, 9, 20, 15, 7]
          ↑
         先访问根

中序遍历: [9, 3, 15, 20, 7]
             ↑
          根的左边是左子树
          根的右边是右子树
```

### 暴力解法分析

**核心观察**:
1. 前序遍历的第一个元素是**根节点**
2. 在中序遍历中找到根节点的位置
3. 根节点左边是**左子树**，右边是**右子树**
4. 递归构造左右子树

**图解**:
```
preorder: [3, 9, 20, 15, 7]
           ↑
          根(3)

inorder:  [9, 3, 15, 20, 7]
              ↑
            根(3)
         左子树  右子树
         [9]    [15,20,7]

递归构造:
- 根节点: 3
- 左子树: preorder=[9], inorder=[9]
- 右子树: preorder=[20,15,7], inorder=[15,20,7]
```

**算法步骤**:
```go
func buildTree(preorder []int, inorder []int) *TreeNode {
    if len(preorder) == 0 {
        return nil
    }

    // 1. 前序第一个元素是根
    rootVal := preorder[0]
    root := &TreeNode{Val: rootVal}

    // 2. 在中序中找到根的位置
    rootIndex := findIndex(inorder, rootVal)

    // 3. 递归构造左右子树
    root.Left = buildTree(
        preorder[1:1+rootIndex],    // 左子树的前序
        inorder[:rootIndex],         // 左子树的中序
    )
    root.Right = buildTree(
        preorder[1+rootIndex:],      // 右子树的前序
        inorder[rootIndex+1:],       // 右子树的中序
    )

    return root
}

func findIndex(arr []int, target int) int {
    for i, v := range arr {
        if v == target {
            return i
        }
    }
    return -1
}
```

**时间复杂度**: O(n²)
- 每个节点需要查找: O(n)
- n个节点: O(n²)

**空间复杂度**: O(n) - 递归栈和切片

**问题**: 每次查找根节点位置需要O(n)，可以优化

### 优化思考 - 哈希表加速查找

**核心问题**: 如何快速在中序遍历中找到根节点位置？

**优化思路**:
1. 预处理: 用哈希表存储 `value → index` 的映射
2. 查找: O(1) 时间找到根节点位置

**优化后的算法**:
```go
func buildTree(preorder []int, inorder []int) *TreeNode {
    // 建立哈希表: value → index
    indexMap := make(map[int]int)
    for i, v := range inorder {
        indexMap[v] = i
    }

    return build(preorder, 0, len(preorder)-1, 0, indexMap)
}

func build(preorder []int, preStart, preEnd, inStart int, indexMap map[int]int) *TreeNode {
    if preStart > preEnd {
        return nil
    }

    // 前序第一个元素是根
    rootVal := preorder[preStart]
    root := &TreeNode{Val: rootVal}

    // 在中序中找到根的位置（O(1)）
    rootIndex := indexMap[rootVal]

    // 左子树大小
    leftSize := rootIndex - inStart

    // 递归构造
    root.Left = build(
        preorder,
        preStart+1,          // 左子树前序起点
        preStart+leftSize,   // 左子树前序终点
        inStart,             // 左子树中序起点
        indexMap,
    )
    root.Right = build(
        preorder,
        preStart+leftSize+1, // 右子树前序起点
        preEnd,              // 右子树前序终点
        rootIndex+1,         // 右子树中序起点
        indexMap,
    )

    return root
}
```

**时间复杂度**: O(n) - 每个节点只处理一次

### 为什么这样思考?

**核心思想**:
1. **分治**: 大问题分解为小问题（构造整棵树 → 构造子树）
2. **前序确定根**: 前序第一个元素就是根
3. **中序分左右**: 根在中序的位置决定左右子树边界
4. **递归构造**: 对左右子树重复上述过程

**为什么前序和中序可以唯一确定二叉树?**
- 前序告诉我们"谁是根"
- 中序告诉我们"哪些是左子树，哪些是右子树"
- 结合两者可以完全确定树的结构

## 解题思路

### 核心思想
利用前序遍历确定根节点，利用中序遍历划分左右子树，递归构造二叉树。

### 详细算法流程

**步骤1: 确定根节点**
```go
rootVal := preorder[0]  // 前序遍历第一个元素是根
root := &TreeNode{Val: rootVal}
```

**关键点**: 前序遍历的特点是"根左右"，第一个元素永远是根

**步骤2: 在中序遍历中找到根的位置**
```go
rootIndex := findIndex(inorder, rootVal)
// 或用哈希表
rootIndex := indexMap[rootVal]
```

**关键点**: 根节点在中序中的位置将数组分为两部分
- 左边: 左子树的所有节点
- 右边: 右子树的所有节点

**步骤3: 计算左右子树大小**
```go
leftSize := rootIndex - inStart  // 左子树节点数
rightSize := len(inorder) - rootIndex - 1  // 右子树节点数
```

**步骤4: 递归构造左右子树**

**图解**:
```
preorder: [3, 9, 20, 15, 7]
           ↑  ↑--------↑
          根  左子树   右子树

inorder:  [9, 3, 15, 20, 7]
           ↑     ↑       ↑
        左子树  根    右子树

rootIndex = 2  (3在中序中的位置)
leftSize = 2  (左子树有2个节点)

左子树:
- preorder: preorder[1:3] = [9, 20]
- inorder: inorder[0:2] = [9, 3]

右子树:
- preorder: preorder[3:5] = [15, 7]
- inorder: inorder[3:5] = [15, 20, 7]
```

### 关键细节说明

**细节1: 为什么是 `preorder[1:1+rootIndex]` 而不是 `preorder[1:rootIndex]`?**

```go
// preorder: [3, 9, 20, 15, 7]
//            ↑  ↑--------↑
//          根(索引0)  左子树(2个元素)

// ❌ 错误写法
root.Left = buildTree(preorder[1:rootIndex], ...)  // [9, 20]? 不对!

// ✅ 正确写法
root.Left = buildTree(preorder[1:1+rootIndex], ...)  // [9]
```

**原因**:
- `preorder[0]` 是根
- `preorder[1:1+leftSize]` 是左子树（共leftSize个元素）
- `preorder[1+leftSize:]` 是右子树

**细节2: 为什么 `inorder[:rootIndex]` 是左子树?**

```go
// inorder: [9, 3, 15, 20, 7]
//            ↑     ↑
//          索引0  根在索引2

// 左子树: inorder[0:2] = [9]
// 右子树: inorder[3:5] = [15, 20, 7]
```

**原因**: 中序遍历是"左根右"，根节点左边全是左子树

**细节3: 如何计算左右子树的边界?**

```go
// 左子树节点数
leftSize := rootIndex - inStart

// 前序边界
preLeftStart := preStart + 1
preLeftEnd := preStart + leftSize

// 中序边界
inLeftStart := inStart
inLeftEnd := rootIndex - 1
```

**图解**:
```
preorder: [根 | 左子树(leftSize个) | 右子树]
          ↑    ↑               ↑
       preStart preStart+1  preStart+leftSize

inorder:  [左子树(leftSize个) | 根 | 右子树]
          ↑                ↑    ↑
       inStart      rootIndex  rootIndex+1
```

### 边界条件分析

**边界1: 空树**
```
输入: preorder = [], inorder = []
输出: nil
处理: 直接返回nil
```

**边界2: 只有根节点**
```
输入: preorder = [1], inorder = [1]
输出: TreeNode{Val: 1}
处理:
- rootVal = 1
- rootIndex = 0
- leftSize = 0
- 左子树: preorder[1:1] = [], inorder[0:0] = []
- 右子树: preorder[1:] = [], inorder[1:] = []
```

**边界3: 只有左子树**
```
输入:
preorder: [1, 2]
inorder:  [2, 1]

输出:
  1
 /
2

处理:
- rootVal = 1, rootIndex = 1
- leftSize = 1
- 左子树: preorder[1:2] = [2], inorder[0:1] = [2]
- 右子树: preorder[2:] = [], inorder[2:] = []
```

**边界4: 只有右子树**
```
输入:
preorder: [1, 2]
inorder:  [1, 2]

输出:
1
 \
  2

处理:
- rootVal = 1, rootIndex = 0
- leftSize = 0
- 左子树: preorder[1:1] = [], inorder[0:0] = []
- 右子树: preorder[1:] = [2], inorder[1:] = [2]
```

### 复杂度分析（详细版）

#### 方法一: 暴力查找

**时间复杂度**:
```
- 构造每个节点: O(1)
- 查找根位置: O(n)
- 总计: n × O(n) = O(n²)

为什么是O(n²)?
- 外层循环: 构造n个节点
- 内层循环: 每次查找O(n)
- 总复杂度: O(n²)
```

**空间复杂度**:
```
- 递归栈: O(h) - h为树高
- 切片: O(n) - 每次创建新切片
- 总计: O(n)
```

#### 方法二: 哈希表优化

**时间复杂度**:
```
- 建立哈希表: O(n)
- 构造每个节点: O(1) - 哈希查找O(1)
- 总计: O(n)

为什么是O(n)?
- 每个节点只处理一次
- 每次处理都是O(1)操作
- 总共n个节点
```

**空间复杂度**:
```
- 哈希表: O(n)
- 递归栈: O(h)
- 总计: O(n)
```

### 执行过程演示

**输入**:
```
preorder = [3, 9, 20, 15, 7]
inorder = [9, 3, 15, 20, 7]
```

**执行过程**:

```
第1层递归:
├─ preorder[0] = 3 是根
├─ 在inorder中找到3，索引=2
├─ 左子树: preorder=[9], inorder=[9]
└─ 右子树: preorder=[20,15,7], inorder=[15,20,7]

第2层递归(左子树):
├─ preorder[0] = 9 是根
├─ 在inorder中找到9，索引=0
├─ 左子树: preorder=[], inorder=[]
└─ 右子树: preorder=[], inorder=[]

第2层递归(右子树):
├─ preorder[0] = 20 是根
├─ 在inorder中找到20，索引=1
├─ 左子树: preorder=[15], inorder=[15]
└─ 右子树: preorder=[7], inorder=[7]

第3层递归(20的左子树):
├─ preorder[0] = 15 是根
├─ 左子树: []
└─ 右子树: []

第3层递归(20的右子树):
├─ preorder[0] = 7 是根
├─ 左子树: []
└─ 右子树: []

最终构造的树:
      3
     / \
    9  20
      /  \
     15   7
```

## 代码实现

### 方法一: 暴力查找（简单直观）

```go
func buildTree(preorder []int, inorder []int) *TreeNode {
    if len(preorder) == 0 {
        return nil
    }

    root := &TreeNode{Val: preorder[0]}
    index := findIndex(inorder, preorder[0])

    root.Left = buildTree(
        preorder[1:1+index],
        inorder[:index],
    )
    root.Right = buildTree(
        preorder[1+index:],
        inorder[index+1:],
    )

    return root
}

func findIndex(arr []int, target int) int {
    for i, v := range arr {
        if v == target {
            return i
        }
    }
    return -1
}
```

**复杂度**: O(n²) 时间，O(n) 空间

### 方法二: 哈希表优化（推荐）

```go
func buildTree(preorder []int, inorder []int) *TreeNode {
    // 建立哈希表: value → index
    indexMap := make(map[int]int)
    for i, v := range inorder {
        indexMap[v] = i
    }

    return build(
        preorder,
        0,
        len(preorder)-1,
        0,
        indexMap,
    )
}

func build(
    preorder []int,
    preStart, preEnd int,
    inStart int,
    indexMap map[int]int,
) *TreeNode {
    if preStart > preEnd {
        return nil
    }

    // 前序第一个元素是根
    rootVal := preorder[preStart]
    root := &TreeNode{Val: rootVal}

    // 在中序中找到根的位置
    rootIndex := indexMap[rootVal]

    // 左子树大小
    leftSize := rootIndex - inStart

    // 递归构造左右子树
    root.Left = build(
        preorder,
        preStart+1,          // 左子树前序起点
        preStart+leftSize,   // 左子树前序终点
        inStart,             // 左子树中序起点
        indexMap,
    )
    root.Right = build(
        preorder,
        preStart+leftSize+1, // 右子树前序起点
        preEnd,              // 右子树前序终点
        rootIndex+1,         // 右子树中序起点
        indexMap,
    )

    return root
}
```

**复杂度**: O(n) 时间，O(n) 空间

## 常见错误

### 错误1: 切片边界错误

❌ **错误写法**:
```go
root.Left = buildTree(preorder[1:index], inorder[:index])
```

✅ **正确写法**:
```go
root.Left = buildTree(preorder[1:1+index], inorder[:index])
```

**原因**: 左子树有index个元素，应该从1到1+index

### 错误2: 忘记处理空数组

❌ **错误写法**:
```go
func buildTree(preorder []int, inorder []int) *TreeNode {
    rootVal := preorder[0]  // 可能越界！
    // ...
}
```

✅ **正确写法**:
```go
func buildTree(preorder []int, inorder []int) *TreeNode {
    if len(preorder) == 0 {
        return nil
    }
    rootVal := preorder[0]
    // ...
}
```

**原因**: 空数组没有第0个元素

### 错误3: 左右子树边界混淆

❌ **错误写法**:
```go
// 错误地认为右子树从rootIndex开始
root.Right = buildTree(preorder[1+index:], inorder[rootIndex:])
```

✅ **正确写法**:
```go
// 右子树从rootIndex+1开始（跳过根节点）
root.Right = buildTree(preorder[1+index:], inorder[rootIndex+1:])
```

**原因**: `inorder[rootIndex]` 是根节点，右子树应该从 `rootIndex+1` 开始

## 变体问题

### 变体1: 从中序与后序遍历构造二叉树

**后序遍历**: 左 → 右 → 根（最后一个元素是根）

```go
func buildTree(inorder []int, postorder []int) *TreeNode {
    indexMap := make(map[int]int)
    for i, v := range inorder {
        indexMap[v] = i
    }

    return build(
        postorder,
        len(postorder)-1,  // 从最后一个元素开始
        0,
        len(inorder)-1,
        indexMap,
    )
}

func build(
    postorder []int,
    postStart, inStart, inEnd int,
    indexMap map[int]int,
) *TreeNode {
    if inStart > inEnd {
        return nil
    }

    rootVal := postorder[postStart]
    root := &TreeNode{Val: rootVal}

    rootIndex := indexMap[rootVal]
    rightSize := inEnd - rootIndex

    root.Right = build(
        postorder,
        postStart-1,
        rootIndex+1,
        inEnd,
        indexMap,
    )
    root.Left = build(
        postorder,
        postStart-1-rightSize,
        inStart,
        rootIndex-1,
        indexMap,
    )

    return root
}
```

### 变体2: 从前序与后序遍历构造二叉树

**注意**: 前序+后序无法唯一确定二叉树（除非是满二叉树）

### 变体3: 判断给定数组是否是某棵树的前序/中序遍历

需要验证数组是否满足遍历的性质（略）

## 总结

**核心要点**:
1. **前序定根**: preorder[0] 永远是当前子树的根
2. **中序分界**: 根在中序的位置决定左右子树边界
3. **递归构造**: 对左右子树重复相同过程
4. **哈希优化**: 用哈希表将查找优化到O(1)

**易错点**:
- 切片边界计算错误（`1:1+index` vs `1:index`）
- 忘记处理空数组
- 左右子树边界混淆（`inorder[rootIndex:]` vs `inorder[rootIndex+1:]`）

**关键规律**:
```
前序: [根 | 左子树 | 右子树]
中序: [左子树 | 根 | 右子树]

通过前序找根，通过中序分左右
```

**推荐写法**: 哈希表优化版（O(n)时间）