LintCode-453: Flatten Binary Tree to Linked List

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;
    }

};