Given two binary search trees root1 and root2.

Return a list containing all the integers from both trees sorted in ascending order.

Example 1:

Input: root1 = [2,1,4], root2 = [1,0,3]
Output: [0,1,1,2,3,4]

Example 2:

Input: root1 = [0,-10,10], root2 = [5,1,7,0,2]
Output: [-10,0,0,1,2,5,7,10]

Example 3:

Input: root1 = [], root2 = [5,1,7,0,2]
Output: [0,1,2,5,7]

Example 4:

Input: root1 = [0,-10,10], root2 = []
Output: [-10,0,10]

Example 5:

Input: root1 = [1,null,8], root2 = [8,1]
Output: [1,1,8,8]

Constraints:

• Each tree has at most 5000 nodes.
• Each node’s value is between [-10^5, 10^5].

Solution: Inorder traversal + Merge Sort

Time complexity: O(t1 + t2)
Space complexity: O(t1 + t2)

// Author: Huahua
class Solution {
public:
  vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {    
    function<void(TreeNode*, vector<int>&)> inorder = [&](TreeNode* root, vector<int>& t) {
      if (!root) return;
      inorder(root->left, t);
      t.push_back(root->val);
      inorder(root->right, t);
    };
    vector<int> t1;
    vector<int> t2;
    inorder(root1, t1);
    inorder(root2, t2);
    vector<int> m;
    int i = 0;
    int j = 0;
    while (m.size() != t1.size() + t2.size()) {
      if (j == t2.size()) m.push_back(t1[i++]);
      else if (i == t1.size()) m.push_back(t2[j++]);
      else m.push_back(t1[i] < t2[j] ? t1[i++] : t2[j++]);      
    }
    return m;
  }
};

// Author: Huahua
class Solution {
public:
  vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {    
    function<void(TreeNode*, vector<int>&)> inorder = [&](TreeNode* root, vector<int>& t) {
      if (!root) return;
      inorder(root->left, t);
      t.push_back(root->val);
      inorder(root->right, t);
    };
    vector<int> t1;
    vector<int> t2;
    inorder(root1, t1);
    inorder(root2, t2);
    vector<int> m;
    std::merge(begin(t1), end(t1), begin(t2), end(t2), back_inserter(m));    
    return m;
  }
};

The post 花花酱 LeetCode 1305. All Elements in Two Binary Search Trees appeared first on Huahua's Tech Road.

• The number of nodes is nodes;
• The value of the i-th node is value[i];
• The parent of the i-th node is parent[i].

Remove every subtree whose sum of values of nodes is zero.

After doing so, return the number of nodes remaining in the tree.

Example 1:

Input: nodes = 7, parent = [-1,0,0,1,2,2,2], value = [1,-2,4,0,-2,-1,-1]
Output: 2

Constraints:

• 1 <= nodes <= 10^4
• -10^5 <= value[i] <= 10^5
• parent.length == nodes
• parent[0] == -1 which indicates that 0 is the root.

Solution: Inorder Traversal

For each node, return the sum of all its subtrees and number of nodes including itself after removal.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int deleteTreeNodes(int nodes, vector<int>& parent, vector<int>& value) {
    vector<vector<int>> g(nodes);
    for (int i = 1; i < nodes; ++i)
      g[parent[i]].push_back(i);    
    // Returns <sum, nodes> of subtree n.
    function<pair<int,int>(int)> traverse = [&](int n) {
      int sum = value[n];
      int count = 1;
      for (int x : g[n]) {
        auto [s, c] = traverse(x);        
        sum += s;
        count += s ? c : 0;
      }
      return make_pair(sum, sum ? count : 0);
    };    
    return traverse(0).second;
  }
};

The post 花花酱 LeetCode 1273. Delete Tree Nodes appeared first on Huahua's Tech Road.

Given the root node of a binary search tree, return the sum of values of all nodes with value between L and R (inclusive).

The binary search tree is guaranteed to have unique values.

Example 1:

Input: root = [10,5,15,3,7,null,18], L = 7, R = 15
Output: 32

Example 2:

Input: root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10
Output: 23

Note:

1. The number of nodes in the tree is at most 10000.
2. The final answer is guaranteed to be less than 2^31.

Solution: In-order traversal

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua, running time: 72 ms
class Solution {
public:
  int rangeSumBST(TreeNode* root, int L, int R) {
    if (!root) return 0;
    int sum = 0;
    if (root->val >= L) sum += rangeSumBST(root->left, L, R);
    if (root->val >= L && root->val <= R) sum += root->val;
    if (root->val <= R) sum += rangeSumBST(root->right, L, R);
    return sum;
  }
};

The post 花花酱 LeetCode 938. Range Sum of BST appeared first on Huahua's Tech Road.

Given a tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only 1 right child.

Example 1:
Input: [5,3,6,2,4,null,8,1,null,null,null,7,9]

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

Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

 1
  \
   2
    \
     3
      \
       4
        \
         5
          \
           6
            \
             7
              \
               8
                \
                 9

Note:

1. The number of nodes in the given tree will be between 1 and 100.
2. Each node will have a unique integer value from 0 to 1000.

Solution: In-order traversal

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Running time: 64 ms
class Solution {
public:
  TreeNode* increasingBST(TreeNode* root) {
    TreeNode dummy(0);
    prev_ = &dummy;
    inorder(root);
    return dummy.right;
  }
private:  
  TreeNode* prev_;
  void inorder(TreeNode* root) {
    if (root == nullptr) return;
    inorder(root->left);
    prev_->right = root;  
    prev_ = root;
    prev_->left = nullptr;
    inorder(root->right);
  }
};

class Solution {
  private TreeNode prev;
  
  public TreeNode increasingBST(TreeNode root) {
    TreeNode dummy = new TreeNode(0);
    this.prev = dummy;
    inorder(root);
    return dummy.right;
  }
  
  private void inorder(TreeNode root) {
    if (root == null) return;
    inorder(root.left);
    this.prev.right = root;
    this.prev = root;
    this.prev.left = null;
    inorder(root.right);
  }
}

class Solution:
  def increasingBST(self, root):
    dummy = TreeNode(0)
    self.prev = dummy
    def inorder(root):
      if not root: return None
      inorder(root.left)
      root.left = None
      self.prev.right = root
      self.prev = root
      inorder(root.right)
    inorder(root)
    return dummy.right

The post 花花酱 LeetCode 897. Increasing Order Search Tree appeared first on Huahua's Tech Road.

Problem

题目大意：把二叉搜索树的每个节点加上比他大的节点的和。

https://leetcode.com/problems/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

Solution: reversed inorder traversal

in a BST, we can visit every node in the decreasing order. Using a member sum to track the sum of all visited nodes.

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 56 ms
class Solution {
public:
  TreeNode* convertBST(TreeNode* root) {
    sum = 0;
    inorder(root);
    return root;
  }
private:
  int sum;
  void rinorder(TreeNode* root) {
    if (root == nullptr) return;
    rinorder(root->right);
    root->val = (sum += root->val);
    rinorder(root->left);
  }
};

The post 花花酱 LeetCode 538. Convert BST to Greater Tree appeared first on Huahua's Tech Road.

题目大意：给你一棵树，返回每一层最大的元素的值。

You need to find the largest value in each row of a binary tree.

Example:

<b>Input:</b> 

          1
         / \
        3   2
       / \   \  
      5   3   9 

<b>Output:</b> [1, 3, 9]

Solution 1: Inorder traversal + depth info

C++

// Author: Huahua
// Running time: 15 ms
class Solution {
public:
  vector<int> largestValues(TreeNode* root) {
    vector<int> ans;
    inorder(root, 0, ans);
    return ans;
  }
private:
  void inorder(TreeNode* root, int d, vector<int>& ans) {
    if (root == nullptr) return;
    while (ans.size() <= d) ans.push_back(INT_MIN);    
    inorder(root->left, d + 1, ans);
    ans[d] = max(ans[d], root->val);
    inorder(root->right, d + 1, ans);
  }
};

Python3

"""
Author: Huahua
Running time: 72 ms (beats 100%)
"""
class Solution:
  def largestValues(self, root):
    def inorder(root, d, ans):
      if not root: return ans
      if len(ans) <= d: ans += [float('-inf')]
      inorder(root.left, d + 1, ans)
      if root.val > ans[d]: ans[d] = root.val
      inorder(root.right, d + 1, ans)
      return ans
    
    return inorder(root, 0, [])

The post 花花酱 LeetCode 515. Find Largest Value in Each Tree Row appeared first on Huahua's Tech Road.

https://leetcode.com/problems/find-bottom-left-tree-value/description/

Problem:

Given a binary tree, find the leftmost value in the last row of the tree.

Example 1:

Input:

    2
   / \
  1   3

Output:
1

Example 2: 

Input:

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

Output:
7

Note: You may assume the tree (i.e., the given root node) is not NULL.

Solution 1: Inorder traversal with depth info

The first node visited in the deepest row is the answer.

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
  int findBottomLeftValue(TreeNode* root) {
    int max_row = -1;    
    int ans;
    dfs(root, 0, max_row, ans);
    return ans;
  }
private:
  void inorder(TreeNode* root, int row, int& max_row, int& ans) {
    if (root == nullptr) return;
    inorder(root->left, row + 1, max_row, ans);
    if (row > max_row) {
      ans = root->val;
      max_row = row;      
    }
    inorder(root->right, row + 1, max_row, ans);
  }
};

Python3

"""
Author: Huahua
Running time: 92 ms
"""
class Solution:
  def inorder(self, root, row):
    if not root: return
    self.inorder(root.left, row + 1)
    if row > self.max_row:
      self.max_row, self.ans = row, root.val
    self.inorder(root.right, row + 1)    
      
  def findBottomLeftValue(self, root):        
    self.ans, self.max_row = 0, -1
    self.inorder(root, 0)
    return self.ans

The post 花花酱 LeetCode 513. Find Bottom Left Tree Value appeared first on Huahua's Tech Road.

Problem:

Given a binary tree, return the postorder traversal of its nodes’ values.

For example:
Given binary tree {1,#,2,3},

1
    \
     2
    /
   3

return [3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

Solution 1:

// Author: Huahua
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;        
        postorderTraversal(root, ans);
        return ans;
    }
    
    void postorderTraversal(TreeNode* root, vector<int>& ans) {
        if (!root) return;
        postorderTraversal(root->left, ans);
        postorderTraversal(root->right, ans);
        ans.push_back(root->val);
    }
};

Solution 2:

// Author: Huahua
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> ans;
        const vector<int> l = postorderTraversal(root->left);
        const vector<int> r = postorderTraversal(root->right);
        ans.insert(ans.end(), l.begin(), l.end());
        ans.insert(ans.end(), r.begin(), r.end());
        ans.push_back(root->val);
        return ans;
    }
};

Solution 3:

// Author: Huahua
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (!root) return {};
        deque<int> ans;
        stack<TreeNode*> s;
        s.push(root);
        while (!s.empty()) {
            TreeNode* n = s.top();
            s.pop();
            ans.push_front(n->val); // O(1)
            if (n->left) s.push(n->left);
            if (n->right) s.push(n->right);
        }   
        return vector<int>(ans.begin(), ans.end());
    }
};

The post 花花酱 LeetCode 145. Binary Tree Postorder Traversal appeared first on Huahua's Tech Road.