LeetCode(114): 二叉树展开为链表

Medium!

题目描述:

给定一个二叉树,原地将它展开为链表。

例如,给定二叉树

    1
   /   2   5
 / \   3   4   6

将其展开为:

1
   2
       3
           4
               5
                   6

解题思路:

这道题要求把二叉树展开成链表,根据展开后形成的链表的顺序分析出是使用先序遍历,那么只要是数的遍历就有递归和非递归的两种方法来求解,这里我们也用两种方法来求解。

首先来看递归版本的,思路是先利用DFS的思路找到最左子节点,然后回到其父节点,把其父节点和右子节点断开,将原左子结点连上父节点的右子节点上,然后再把原右子节点连到新右子节点的右子节点上,然后再回到上一父节点做相同操作。

C++解法一:

 1 // Recursion
 2 class Solution {
 3 public:
 4     void flatten(TreeNode *root) {
 5         if (!root) return;
 6         if (root->left) flatten(root->left);
 7         if (root->right) flatten(root->right);
 8         TreeNode *tmp = root->right;
 9         root->right = root->left;
10         root->left = NULL;
11         while (root->right) root = root->right;
12         root->right = tmp;
13     }
14 };

例如,对于下面的二叉树,上述算法的变换的过程如下:

     1
    /    2   5
  / \    3   4   6

     1
    /    2   5
    \        3   6
      \
       4

   1
         2
             3
                 4
                     5
                         6

下面我们再来看非迭代版本的实现,这个方法是从根节点开始出发,先检测其左子结点是否存在,如存在则将根节点和其右子节点断开,将左子结点及其后面所有结构一起连到原右子节点的位置,把原右子节点连到原左子结点最后面的右子节点之后。

C++解法二:

 1 // Non-recursion
 2 class Solution {
 3 public:
 4     void flatten(TreeNode *root) {
 5         TreeNode *cur = root;
 6         while (cur) {
 7             if (cur->left) {
 8                 TreeNode *p = cur->left;
 9                 while (p->right) p = p->right;
10                 p->right = cur->right;
11                 cur->right = cur->left;
12                 cur->left = NULL;
13             }
14             cur = cur->right;
15         }
16     }
17 };

例如,对于下面的二叉树,上述算法的变换的过程如下:

     1
    /    2   5
  / \    3   4   6

   1
         2
    /    3   4
                 5
                     6

   1
         2
             3
                 4
                     5
                         6

前序迭代解法如下:

C++解法三:

 1 class Solution {
 2 public:
 3     void flatten(TreeNode* root) {
 4         if (!root) return;
 5         stack<TreeNode*> s;
 6         s.push(root);
 7         while (!s.empty()) {
 8             TreeNode *t = s.top(); s.pop();
 9             if (t->left) {
10                 TreeNode *r = t->left;
11                 while (r->right) r = r->right;
12                 r->right = t->right;
13                 t->right = t->left;
14                 t->left = NULL;
15             }
16             if (t->right) s.push(t->right);
17         }
18     }
19 };

此题还可以延伸到用中序,后序,层序的遍历顺序来展开原二叉树,分别又有其对应的递归和非递归的方法,有兴趣的童鞋可以自行实现。

原文地址:https://www.cnblogs.com/ariel-dreamland/p/9162548.html

时间: 2024-11-06 11:31:11

LeetCode(114): 二叉树展开为链表的相关文章

[LeetCode] 114. 二叉树展开为链表 ☆☆☆(深度遍历)

二叉树展开为链表(很详细) 描述 给定一个二叉树,原地将它展开为链表. 例如,给定二叉树 1 / \ 2 5 / \ \3 4 6将其展开为: 1 \ 2 \ 3 \ 4 \ 5 \ 6 解析 变形的后续遍历 直觉是先序遍历,但是节点会丢失,可以使用后续遍历. 我们依次遍历 6 5 4 3 2 1,然后每遍历一个节点就将当前节点的右指针更新为上一个节点. 遍历到 5,把 5 的右指针指向 6.6 <- 5 4 3 2 1. 遍历到 4,把 4 的右指针指向 5.6 <- 5 <- 4 3

leetcode 114. 二叉树展开为链表(dfs)

给定一个二叉树,原地将它展开为链表. 例如,给定二叉树 1 / \ 2 5 / \ \3 4 6将其展开为: 1 \    2    \ 3 \ 4 \ 5 \ 6 来源:力扣(LeetCode)链接:https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNod

LeetCode 114. 二叉树展开为链表(Flatten Binary Tree to Linked List)

题目描述 给定一个二叉树,原地将它展开为链表. 例如,给定二叉树 1 / 2 5 / \ 3 4 6 将其展开为: 1 2 3 4 5 6 解题思路 二叉树转化为链表的基本思想是:对于左孩子转化为右孩子:对于右孩子,拼接到根结点左子树最后一个节点作为右孩子.所以在自上而下转化时,对于每个节点要先保存其右孩子,然后记录转为链表后本子树的最后一个节点并返回给上一个根节点. 代码 1 /** 2 * Definition for a binary tree node. 3 * struct TreeN

leetcode 114. 二叉树展开为链表(Flatten Binary Tree to Linked List)

目录 题目描述: 示例: 解法: 题目描述: 给定一个二叉树,原地将它展开为链表. 示例: 给定二叉树 1 / 2 5 / \ 3 4 6 将其展开为: 1 2 3 4 5 6 解法: /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NU

[LeetCode] 114. 二叉树展开为链表

题目链接 : https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/ 题目描述: 给定一个二叉树,原地将它展开为链表. 示例: 例如,给定二叉树 1 / 2 5 / \ 3 4 6 将其展开为: 1 2 3 4 5 6 思路: 其实对于这种题目,递归不太好想的,可以有个取巧的方法,就是把树转列表,因为结果是按照前序遍历的,所以有: def flatten(self, root: TreeNode) -> None:

114. 二叉树展开为链表

1 /** 2 * Definition for a binary tree node. 3 * struct TreeNode { 4 * int val; 5 * TreeNode *left; 6 * TreeNode *right; 7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 * }; 9 */ 10 11 class Solution 12 { 13 public: 14 void flatten(TreeNod

[LeetCode] Flatten Binary Tree to Linked List 将二叉树展开成链表

Given a binary tree, flatten it to a linked list in-place. For example,Given 1 / 2 5 / \ 3 4 6 The flattened tree should look like: 1 2 3 4 5 6 click to show hints. Hints: If you notice carefully in the flattened tree, each node's right child points

[LintCode] Flatten Binary Tree to Linked List 将二叉树展开成链表

Flatten a binary tree to a fake "linked list" in pre-order traversal. Here we use the right pointer in TreeNode as the next pointer in ListNode. Notice Don't forget to mark the left child of each node to null. Or you will get Time Limit Exceeded

leecode第一百一十四题(二叉树展开为链表)

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: void flatten(TreeNode* root) { if(root==NULL)//记住!roo