LintCode-453: Flatten Binary Tree to Linked List

原创已于 2023-09-25 15:30:38 修改 · 187 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

于 2018-06-12 15:52:37 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文介绍如何将二叉树按前序遍历的方式展平为链表，并提供了几种不同的实现方法，包括递归法及使用辅助栈的方法。

453 · Flatten Binary Tree to Linked List
Algorithms
Easy
Description

Description
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.

Don’t forget to mark the left child of each node to null. Or you will get Time Limit Exceeded or Memory Limit Exceeded.

Example
Example 1:

Input:{1,2,5,3,4,#,6}
Output：{1,#,2,#,3,#,4,#,5,#,6}
Explanation：
1
/
2 5
/ \
3 4 6

1

2

3

4

5

6
Example 2:

Input:{1}
Output:{1}
Explanation：
1
1
Challenge
Do it in-place without any extra memory.
解法1：
用的遍历法(递归）

void flatten(TreeNode * root) {
        if (!root) 
            return;
        
        flatten(root->left);
        flatten(root->right);
        TreeNode* saveRight = root->right;
        root->right=root->left;
        root->left=NULL; //注意这一行要加
        while(root->right)
            root=root->right;
        root->right=saveRight;    
    }

解法2：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: a TreeNode, the root of the binary tree
     * @return: nothing
     */
    void flatten(TreeNode *root) {
        if (!root) return;
        preOrderTraversal(root);
        for (int i = 0; i < vec.size() - 1; i++) {
            vec[i]->right = vec[i + 1];
            vec[i]->left = nullptr;
        }
        return;
    }
private:
    void preOrderTraversal(TreeNode *root) {
        if (root) {
            vec.push_back(root);
            preOrderTraversal(root->left);
            preOrderTraversal(root->right);
        }
        return;
    }
    TreeNode *pre = nullptr;
    vector<TreeNode *> vec;
};

三刷：

class Solution {
public:
    void flatten(TreeNode* root) {
        if (!root) return;
        helper(root);
    }
private:
    TreeNode * helper(TreeNode *node) {
        if (!node) return NULL;
        TreeNode *leftNode = helper(node->left);
        TreeNode *rightNode = helper(node->right);
        if (leftNode) {
            TreeNode *tmp = leftNode;
            node->right = leftNode;

            while (tmp && tmp->right) {
                tmp = tmp->right;
            }
            if (tmp) tmp->right = rightNode;
            node->left = NULL;
        }
        return node;
    }
};

四刷:

class Solution {
public:
    void flatten(TreeNode* root) {
        if (!root) return;
        flatten(root->left);
        flatten(root->right);
        TreeNode *leftNode = root->left;
        TreeNode *rightNode = root->right;
        root->left = NULL;
        root->right = leftNode;
        while (root->right) {
            root = root->right;
        }
        root->right = rightNode;
        return;
    }

};