114. Flatten Binary Tree to Linked List\538. Convert BST to Greater Tree

114. Flatten Binary Tree to Linked List

DESCRIPTION

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

This problem changes the tree into a linked list.

My algorithm is below: I use iterative method to do pre-order and store the right node to the stack and point the current node to left-node, set left node to NULL. Do this operation until the stack is empty.

IMPLEMENTATION

The code is below:

/**
 * 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) 
            return;
        stack<TreeNode*> que;
        TreeNode* cur = root;
        if(root->right) que.push(root->right);
        if(root->left)  que.push(root->left);

        while(!que.empty()) {
            TreeNode* left = que.top();
            que.pop();
            cur->left = NULL;
            cur->right = left;
            if(left->right) que.push(left->right);
            if(left->left) que.push(left->left);
            cur = cur->right;
        }
    }
};

538. Convert BST to Greater Tree

DESCRIPTION

Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST.

Example:

Input: The root of a Binary Search Tree like this:

              5
            /   \
           2     13

Output: The root of a Greater Tree like this:

             18
            /   \
          20     13

This problem is a pre-order problem, from this we can see that the node is the accumulated by its own value and its right sub-tree accumulated value.

So here I change the order of tree with the right node first then its left tree node, and a global value stores the last node value to assign to the newer node.

IMPLEMENTATION

The code shows below:

/**
 * 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:
    int last = 0;
    bool hasValue = false;
    void findRightSum(TreeNode* root) {
        if(!root) return;
        if(root->right) findRightSum(root->right);
        root->val += last;
        last = root->val;  
        if(root->left)  findRightSum(root->left);
    }

    TreeNode* convertBST(TreeNode* root) {
        if(!root) 
            return root;
        findRightSum(root);
        return root;
    }
};