114-二叉树-二叉树展开为链表-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_46060468/article/details/143419153

栈 | 树 | 深度优先搜索 | 链表 | 二叉树

你的思路和代码逻辑基本正确，利用递归将二叉树展开为单链表，同时保持先序遍历的顺序。下面我将对这个过程进行详细的讲解，包括思路、代码实现、以及更清晰的解释和示例。

问题分析

目标

将给定的二叉树展开为一个单链表，要求：

链表中的节点顺序与二叉树的先序遍历顺序一致。
链表的右指针指向下一个节点，左指针始终为 null。

先序遍历回顾

先序遍历的顺序是：

访问根节点
先序遍历左子树
先序遍历右子树

例如，对于以下二叉树：

先序遍历的顺序为：1 -> 2 -> 3 -> 4 -> 5 -> 6

代码实现

下面是实现该功能的代码：

// 定义二叉树节点
class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

// 展开二叉树为单链表
var flatten = function(root) {
    // 递归终止条件
    if (root === null) return null;
    
    // 分别递归左右节点
    const left = root.left; // 保存左子树
    const right = root.right; // 保存右子树

    flatten(left); // 递归处理左子树
    flatten(right); // 递归处理右子树
    
    // 将树的右节点替换为左节点
    root.right = left; // 将左子树接到右边
    root.left = null; // 左指针始终为 null

    // 找到左子树的最右节点
    let current = root;
    while (current.right) {
        current = current.right; // 遍历到右子树的最右节点
    }
    
    // 将最右节点的右指针指向原来的右子树
    current.right = right; 
};

// 示例测试
const buildSampleTree = () => {
  const root = new TreeNode(1);
  root.left = new TreeNode(2);
  root.right = new TreeNode(5);
  root.left.left = new TreeNode(3);
  root.left.right = new TreeNode(4);
  root.right.right = new TreeNode(6);
  return root;
};

const printFlattenedTree = (root) => {
  let current = root;
  while (current) {
    console.log(current.value);
    current = current.right; // 只遍历右指针
  }
};

// 构建示例树并展开
const root = buildSampleTree();
flatten(root);
printFlattenedTree(root); // 输出展开后的链表

代码解析

1. 递归终止条件

if (root === null) return null;

如果当前节点为空，直接返回 null。

2. 保存左右子树

const left = root.left; 
const right = root.right;

保存当前节点的左子树和右子树，以便后续操作。

3. 递归处理左右子树

flatten(left);
flatten(right);

递归调用自身，处理左子树和右子树。

4. 替换右节点

root.right = left; 
root.left = null;

将当前节点的右指针指向左子树，并将左指针设置为 null。

5. 找到最右节点

let current = root;
while (current.right) {
    current = current.right; 
}

使用 current 指针遍历到左子树的最右节点。

6. 连接原右子树

current.right = right;

将最右节点的右指针指向原来的右子树。

示例推导过程

让我们通过示例树 1 -> 2 -> 3 -> 4 -> 5 -> 6 的推导过程来详细说明。

初始树结构

执行步骤

初始调用 flatten(1):
- 当前节点 1
- 保存左子树 2，右子树 5
- 递归调用 flatten(2)。
处理节点 2:
- 当前节点 2
- 保存左子树 3，右子树 4
- 递归调用 flatten(3)。
处理节点 3:
- 当前节点 3
- 左子树和右子树均为 null
- 返回。
返回到节点 2:
- 继续处理右子树 4
- 递归调用 flatten(4)。
处理节点 4:
- 当前节点 4
- 左子树和右子树均为 null
- 返回。
返回到节点 2:
- 将 2 的右指针指向 3，左指针设为 null
- 将 3 的右指针指向 4。
- 结果：
```
    2
     \
      3
       \
        4
```
返回到节点 1:
- 现在处理右子树 5
- 递归调用 flatten(5)。
处理节点 5:
- 当前节点 5
- 左子树为 null，右子树为 6
- 递归调用 flatten(6)。
处理节点 6:
- 当前节点 6
- 左子树和右子树均为 null
- 返回。
返回到节点 5:
- 将 5 的右指针指向 6，左指针设为 null。
- 结果：
```
    5
     \
      6
```
返回到节点 1:
- 将 1 的右指针指向 2，左指针设为 null。
- 将 4 的右指针指向 5。
- 最终结果：
```
1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6
```

输出结果

通过 printFlattenedTree 函数打印展开后的链表，输出结果为：

好的，让我们深入探讨为什么可以通过将二叉树的结构转换为链表的方式来实现二叉树的展开，并解释背后的想法和推理。

理论基础

1. 先序遍历的性质

在先序遍历中，我们遵循以下顺序访问节点：

访问根节点
先序遍历左子树
先序遍历右子树

因此，展开后的链表的结构必须遵循这一顺序。我们的目标是将二叉树的每个节点按这个顺序连接起来。

2. 树的结构特性

二叉树的每个节点都有：

一个左子树
一个右子树

在展开过程中，我们可以利用这两个特性，将二叉树的结构重新调整为链表的结构。具体来说，我们可以将每个节点的左子树“移”到右子树的位置，而不是真正删除左子树。

具体推理

3. 递归的思路

通过递归，我们可以逐步处理每个节点。以下是具体的推理过程：

处理当前节点：
- 对于每个节点，我们首先保存其左子树和右子树的引用，以便在后续操作中使用。
递归展开子树：
- 递归调用 flatten 函数来处理左子树和右子树。这意味着我们会先将左子树和右子树各自展开为链表。
重新连接节点：
- 将当前节点的右指针指向左子树的根节点（即 root.right = left），并将左指针设置为 null（即 root.left = null）。
- 这样，当前节点的右指针现在指向了左子树的链表。
找到左子树的最右节点：
- 由于左子树已经被转化为链表，我们需要找到这个链表的最后一个节点（即左子树的最右节点）。
- 可以通过一个循环来遍历到这个最右节点。
连接右子树：
- 最右节点的右指针需要指向原来的右子树（即 current.right = right），这样就完成了整个树的展开。

4. 递归的结束条件

递归会在遇到空节点时结束（即 if (root === null) return null;），这确保了所有节点都能被正确处理。

5. 整体推理

树的结构：由于二叉树的每个节点都可以被视为一个子树，递归地展开每个子树就能确保最终的链表结构是正确的。
先序遍历的顺序：通过将左子树放在右边，并在最后连接右子树，确保了链表的节点顺序与先序遍历的顺序一致。

例子分析

让我们用一个简单的例子来验证这个思路。

示例树

展开过程

处理节点 1：
- 保存左子树 2 和右子树 5。
- 递归展开左子树 2。
处理节点 2：
- 保存左子树 3 和右子树 4。
- 递归展开左子树 3。
处理节点 3：
- 节点 3 没有子树，返回。
返回到节点 2：
- 递归展开右子树 4。
处理节点 4：
- 节点 4 没有子树，返回。
- 将 2 的右指针指向 3，然后指向 4。此时 2 的左指针设为 null。
返回到节点 1：
- 现在处理右子树 5。
处理节点 5：
- 递归展开右子树 6。
处理节点 6：
- 节点 6 没有子树，返回。
- 将 1 的右指针指向 2，然后通过 4 指向 5，最后通过 5 指向 6。

最终链表

1 -> 2 -> 3 -> 4 -> 5 -> 6

总结

通过这种递归的方法，我们可以有效地将二叉树展开为一个链表，且保持先序遍历的顺序。关键在于利用树的结构特性和递归的思想，逐步将每个节点的左子树转移到右边，同时正确连接所有节点的右指针。这样，我们既能保持代码的简洁性，又能确保性能的高效性。这种方法不仅适用于二叉树的展开，也可以推广到其他树结构的处理。

好的，让我们通过你提供的二叉树示例，详细推导将其展开为单链表的过程。我们将使用先序遍历的方式来连接树的节点。给定的二叉树如下：

    1
   / \
  2   5
 / \   / \
3   4 6   7

目标

我们希望将这个二叉树展开为一个单链表，链表的结构应为：

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7

展开的过程

1. 解析树的结构

首先，我们来分析这个树的结构：

根节点: 1
左子树:
- 根节点 2
- 左子树 3，右子树 4
右子树:
- 根节点 5
- 左子树 6，右子树 7

2. 使用递归展开树

我们将使用递归的方式来处理这个树。以下是具体的步骤：

初始调用

调用 flatten(1)，当前节点为 1。
保存左子树 2 和右子树 5。

处理左子树 `2`

递归调用 flatten(2)，当前节点为 2。
保存左子树 3 和右子树 4。

处理左子树 `3`

递归调用 flatten(3)，当前节点为 3。
3 的左右子树均为 null，直接返回。

返回到节点 `2`

继续递归处理右子树 4。

处理右子树 `4`

递归调用 flatten(4)，当前节点为 4。
4 的左右子树均为 null，直接返回。

连接节点 `2`

现在我们回到节点 2，根据展开的逻辑进行连接：

将 2 的右指针指向 3（左子树的根）。
将 2 的左指针设为 null。
找到 3 的最右节点（即 3 本身），并将其右指针指向 4。

此时，节点 2 的结构如下：

3. 返回到根节点 `1`

接下来，我们返回到根节点 1，现在处理右子树 5。

处理右子树 `5`

递归调用 flatten(5)，当前节点为 5。
保存左子树 6 和右子树 7。

处理左子树 `6`

递归调用 flatten(6)，当前节点为 6。
6 的左右子树均为 null，直接返回。

返回到节点 `5`

继续递归处理右子树 7。

处理右子树 `7`

递归调用 flatten(7)，当前节点为 7。
7 的左右子树均为 null，直接返回。

连接节点 `5`

现在我们回到节点 5，进行连接：

将 5 的右指针指向 6（左子树的根）。
将 5 的左指针设为 null。
找到 6 的最右节点（即 6 本身），并将其右指针指向 7。

此时，节点 5 的结构如下：

4. 连接根节点 `1`

现在我们回到根节点 1，进行最终的连接：

将 1 的右指针指向 2（左子树的根）。
将 1 的左指针设为 null。
找到 2 的最右节点（即 4），并将其右指针指向 5（右子树的根）。

最终的展开结构如下：

5. 完整链表输出

通过 printFlattenedTree 函数遍历这个链表，我们可以得到以下输出：

总结

通过递归地处理每个节点，我们能够将二叉树展开为单链表，保持先序遍历的顺序。这种方法的关键在于：

递归处理每个节点的左右子树。
利用最右节点连接原右子树。
确保链表的结构符合先序遍历的顺序。

好的，让我们通过一个高度为 4 的满二叉树的例子，详细推导将其展开为单链表的过程。我们将使用先序遍历的顺序来连接树的节点。首先，我们来构建这棵满二叉树。

满二叉树的结构

高度为 4 的满二叉树的节点数为 (2^4 - 1 = 15)。其结构如下：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7
  / \ / \/ \ / \
 8  9 10 11 12 13 14 15

先序遍历

先序遍历的顺序为：

访问根节点
先序遍历左子树
先序遍历右子树

根据上述树，先序遍历的结果为：

1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15

目标

我们的目标是将这个二叉树展开为一个单链表，链表的结构应为：

1 -> 2 -> 4 -> 8 -> 9 -> 5 -> 10 -> 11 -> 3 -> 6 -> 12 -> 13 -> 7 -> 14 -> 15

展开的过程

我们将使用递归的方式来处理这个树。以下是具体的步骤：

初始调用

调用 flatten(1)，当前节点为 1。
保存左子树 2 和右子树 3。

处理左子树 `2`

递归调用 flatten(2)，当前节点为 2。
保存左子树 4 和右子树 5。

处理左子树 `4`

递归调用 flatten(4)，当前节点为 4。
保存左子树 8 和右子树 9。

处理左子树 `8`

递归调用 flatten(8)，当前节点为 8。
8 的左右子树均为 null，直接返回。

返回到节点 `4`

继续递归处理右子树 9。

处理右子树 `9`

递归调用 flatten(9)，当前节点为 9。
9 的左右子树均为 null，直接返回。

连接节点 `4`

现在我们回到节点 4，进行连接：

将 4 的右指针指向 8（左子树的根）。
将 4 的左指针设为 null。
找到 8 的最右节点（即 8 本身），并将其右指针指向 9。

此时，节点 4 的结构如下：

继续处理节点 `2`

返回到节点 2，现在处理右子树 5。

处理右子树 `5`

递归调用 flatten(5)，当前节点为 5。
保存左子树 10 和右子树 11。

处理左子树 `10`

递归调用 flatten(10)，当前节点为 10。
10 的左右子树均为 null，直接返回。

返回到节点 `5`

继续递归处理右子树 11。

处理右子树 `11`

递归调用 flatten(11)，当前节点为 11。
11 的左右子树均为 null，直接返回。

连接节点 `5`

现在我们回到节点 5，进行连接：

将 5 的右指针指向 10（左子树的根）。
将 5 的左指针设为 null。
找到 10 的最右节点（即 10 本身），并将其右指针指向 11。

此时，节点 5 的结构如下：

连接节点 `2`

现在我们回到节点 2，进行连接：

将 2 的右指针指向 4（左子树的根）。
将 2 的左指针设为 null。
找到 4 的最右节点（即 9），并将其右指针指向 5（右子树的根）。

继续处理根节点 `1`

返回到根节点 1，现在处理右子树 3。

处理右子树 `3`

递归调用 flatten(3)，当前节点为 3。
保存左子树 6 和右子树 7。

处理左子树 `6`

递归调用 flatten(6)，当前节点为 6。
保存左子树 12 和右子树 13。

处理左子树 `12`

递归调用 flatten(12)，当前节点为 12。
12 的左右子树均为 null，直接返回。

返回到节点 `6`

继续递归处理右子树 13。

处理右子树 `13`

递归调用 flatten(13)，当前节点为 13。
13 的左右子树均为 null，直接返回。

连接节点 `6`

现在我们回到节点 6，进行连接：

将 6 的右指针指向 12（左子树的根）。
将 6 的左指针设为 null。
找到 12 的最右节点（即 12 本身），并将其右指针指向 13。

继续处理节点 `3`

返回到节点 3，现在处理右子树 7。

处理右子树 `7`

递归调用 flatten(7)，当前节点为 7。
保存左子树 14 和右子树 15。

处理左子树 `14`

递归调用 flatten(14)，当前节点为 14。
14 的左右子树均为 null，直接返回。

返回到节点 `7`

继续递归处理右子树 15。

处理右子树 `15`

递归调用 flatten(15)，当前节点为 15。
15 的左右子树均为 null，直接返回。

连接节点 `7`

现在我们回到节点 7，进行连接：

将 7 的右指针指向 14（左子树的根）。
将 7 的左指针设为 null。
找到 14 的最右节点（即 14 本身），并将其右指针指向 15。

最终连接根节点 `1`

现在我们回到根节点 1，进行最终的连接：

将 1 的右指针指向 2（左子树的根）。
将 1 的左指针设为 null。
找到 2 的最右节点（即 11），并将其右指针指向 3（右子树的根）。

最终链表结构

通过以上步骤，我们最终得到的链表结构如下：

1 -> 2 -> 4 -> 8 -> 9 -> 5 -> 10 -> 11 -> 3 -> 6 -> 12 -> 13 -> 7 -> 14 -> 15

输出结果

通过遍历这个链表，我们可以得到以下输出：

总结

通过递归地处理每个节点，我们能够将高度为 4 的满二叉树展开为单链表，并保持先序遍历的顺序。关键在于：

递归处理每个节点的左右子树。
利用最右节点连接原右子树。
确保链表的结构符合先序遍历的顺序。

这种方法简单而高效，适合处理任何形式的满二叉树。如果你有更多问题或者需要进一步的解释，请随时告诉我！

114-二叉树-二叉树展开为链表

栈 | 树 | 深度优先搜索 | 链表 | 二叉树

问题分析

目标

先序遍历回顾

代码实现

代码解析

1. 递归终止条件

2. 保存左右子树

3. 递归处理左右子树

4. 替换右节点

5. 找到最右节点

6. 连接原右子树

示例推导过程

初始树结构

执行步骤

输出结果

理论基础

1. 先序遍历的性质

2. 树的结构特性

具体推理

3. 递归的思路

4. 递归的结束条件

5. 整体推理

例子分析

示例树

展开过程

最终链表

总结

目标

展开的过程

1. 解析树的结构

2. 使用递归展开树

初始调用

处理左子树 2

处理左子树 3

返回到节点 2

处理右子树 4

连接节点 2

3. 返回到根节点 1

处理右子树 5

处理左子树 6

返回到节点 5

处理右子树 7

连接节点 5

4. 连接根节点 1

5. 完整链表输出

总结

满二叉树的结构

先序遍历

目标

展开的过程

初始调用

处理左子树 2

处理左子树 4

处理左子树 8

返回到节点 4

处理右子树 9

连接节点 4

继续处理节点 2

处理右子树 5

处理左子树 10

返回到节点 5

处理右子树 11

连接节点 5

连接节点 2

继续处理根节点 1

处理右子树 3

处理左子树 6

处理左子树 12

返回到节点 6

处理右子树 13

连接节点 6

继续处理节点 3

处理右子树 7

处理左子树 14

返回到节点 7

处理右子树 15

连接节点 7

最终连接根节点 1

处理左子树 `2`

处理左子树 `3`

返回到节点 `2`

处理右子树 `4`

连接节点 `2`

3. 返回到根节点 `1`

处理右子树 `5`

处理左子树 `6`

返回到节点 `5`

处理右子树 `7`

连接节点 `5`

4. 连接根节点 `1`

处理左子树 `2`

处理左子树 `4`

处理左子树 `8`

返回到节点 `4`

处理右子树 `9`

连接节点 `4`

继续处理节点 `2`

处理右子树 `5`

处理左子树 `10`

返回到节点 `5`

处理右子树 `11`

连接节点 `5`

连接节点 `2`

继续处理根节点 `1`

处理右子树 `3`

处理左子树 `6`

处理左子树 `12`

返回到节点 `6`

处理右子树 `13`

连接节点 `6`

继续处理节点 `3`

处理右子树 `7`

处理左子树 `14`

返回到节点 `7`

处理右子树 `15`

连接节点 `7`

最终连接根节点 `1`