struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Example 1:

Input: root = [1,2,3,4,5,null,7]
Output: [1,#,2,3,#,4,5,7,#]
Explanation: Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.

Example 2:

Input: root = []
Output: []

Constraints:

• The number of nodes in the tree is in the range [0, 6000].
• -100 <= Node.val <= 100

Follow-up:

• You may only use constant extra space.
• The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.

Solution -2: Group nodes into levels

Use pre-order traversal to group nodes by levels.
Connects nodes in each level.

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

// Author: Huahua
class Solution {
public:
  Node* connect(Node* root) {
    vector<vector<Node*>> levels;
    dfs(root, 0, levels);
    for (auto& nodes : levels)
      for(int i = 0; i < nodes.size() - 1; ++i)
        nodes[i]->next = nodes[i+1]; 
    return root;
  }
private:
  void dfs(Node *root, int d, vector<vector<Node*>>& levels) {
    if (!root) return;
    if (levels.size() < d+1) levels.push_back({});
    levels[d].push_back(root);
    dfs(root->left, d + 1, levels);
    dfs(root->right, d + 1, levels);
  }
};

Solution -1: BFS level order traversal

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

// Author: Huahua
class Solution {
public:
  Node* connect(Node* root) {
    if (!root) return root;
    queue<Node*> q{{root}};
    while (!q.empty()) {
      int size = q.size();
      Node* p = nullptr;
      while (size--) {
        Node* t = q.front(); q.pop();
        if (p) 
          p->next = t, p = p->next;
        else
          p = t;
        if (t->left) q.push(t->left);
        if (t->right) q.push(t->right);
      }
    }
    return root;
  }
};

Solution 1: BFS w/o extra space

Populating the next level while traversing current level.

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

// Author: Huahua
class Solution {
public:
  Node* connect(Node* root) {
    Node* p = root;        
    while (p) {
      Node dummy;
      Node* c = &dummy;
      while (p) {
        if (p->left)
          c->next = p->left, c = c->next;
        if (p->right)
          c->next = p->right, c = c->next;
        p = p->next;
      }
      p = dummy.next;
    }
    return root;
  }
};

The post 花花酱 LeetCode 117. Populating Next Right Pointers in Each Node II appeared first on Huahua's Tech Road.

Example:

Input: [1,null,2,3]
   1
    \
     2
    /
   3

Output: [1,2,3]

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

Solution 1: Recursion

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

// Author: Huahua
class Solution {
public:
  vector<int> preorderTraversal(TreeNode* root) {
    vector<int> ans;    
    function<void(TreeNode*)> preorder = [&](TreeNode* n) {
      if (!n) return;
      ans.push_back(n->val);
      preorder(n->left);
      preorder(n->right);
    };
    preorder(root);
    return ans;
  }
};

Solution 2: Stack

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

// Author: Huahua
class Solution {
public:
  vector<int> preorderTraversal(TreeNode* root) {
    vector<int> ans;
    stack<TreeNode*> s;
    if (root) s.push(root);
    while (!s.empty()) {
      TreeNode* n = s.top();
      ans.push_back(n->val);
      s.pop();
      if (n->right) s.push(n->right);
      if (n->left) s.push(n->left);            
    }
    return ans;
  }

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

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.

For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1) and (X+1, Y-1).

Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).

If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.

Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.

Example 1:

Input: [3,9,20,null,null,15,7]
Output: [[9],[3,15],[20],[7]]
Explanation: 
Without loss of generality, we can assume the root node is at position (0, 0):
Then, the node with value 9 occurs at position (-1, -1);
The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
The node with value 20 occurs at position (1, -1);
The node with value 7 occurs at position (2, -2).

Example 2:

Input: [1,2,3,4,5,6,7]
Output: [[4],[2],[1,5,6],[3],[7]]
Explanation: 
The node with value 5 and the node with value 6 have the same position according to the given scheme.
However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.

Note:

1. The tree will have between 1 and 1000 nodes.
2. Each node’s value will be between 0 and 1000.

Solution: Ordered Map+ Ordered Set

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

// Author: Huahua, running time: 0 ms, 921.6 KB 
class Solution {
public:
  vector<vector<int>> verticalTraversal(TreeNode* root) {
    if (!root) return {};
    int min_x = INT_MAX;
    int max_x = INT_MIN;
    map<pair<int, int>, multiset<int>> h; // {y, x} -> {vals}
    traverse(root, 0, 0, h, min_x, max_x);
    vector<vector<int>> ans(max_x - min_x + 1);
    for (const auto& m : h) {      
      int x = m.first.second - min_x;
      ans[x].insert(end(ans[x]), begin(m.second), end(m.second));
    }
    return ans;
  }
private:
  void traverse(TreeNode* root, int x, int y, 
                map<pair<int, int>, multiset<int>>& h,
                int& min_x,
                int& max_x) {
    if (!root) return;
    min_x = min(min_x, x);
    max_x = max(max_x, x);    
    h[{y, x}].insert(root->val);
    traverse(root->left, x - 1, y + 1, h, min_x, max_x);
    traverse(root->right, x + 1, y + 1, h, min_x, max_x);
  }
};

# Author: Huahua, 36 ms, 6.8 MB
class Solution:
  def verticalTraversal(self, root: 'TreeNode') -> 'List[List[int]]':
    if not root: return []    
    vals = []
    def preorder(root, x, y):
      if not root: return
      vals.append((x, y, root.val))
      preorder(root.left, x - 1, y + 1)
      preorder(root.right, x + 1, y + 1)
    preorder(root, 0, 0)    
    ans = []
    last_x = -1000
    for x, y, val in sorted(vals):
      if x != last_x:
        ans.append([])
        last_x = x
      ans[-1].append(val)
    return ans

The post 花花酱 LeetCode 987. Vertical Order Traversal of a Binary Tree appeared first on Huahua's Tech Road.

A node in this binary tree can be flipped by swapping the left child and the right child of that node.

Consider the sequence of N values reported by a preorder traversal starting from the root.  Call such a sequence of N values the voyage of the tree.

(Recall that a preorder traversal of a node means we report the current node’s value, then preorder-traverse the left child, then preorder-traverse the right child.)

Our goal is to flip the least number of nodes in the tree so that the voyage of the tree matches the voyagewe are given.

If we can do so, then return a list of the values of all nodes flipped.  You may return the answer in any order.

If we cannot do so, then return the list [-1].

Example 1:

Input: root = [1,2], voyage = [2,1]
Output: [-1]

Example 2:

Input: root = [1,2,3], voyage = [1,3,2]
Output: [1]

Example 3:

Input: root = [1,2,3], voyage = [1,2,3]
Output: []

Note:

1. 1 <= N <= 100

Solution: Pre-order traversal

if root->val != v[pos] return [-1]
if root->left?->val != v[pos + 1], swap the nodes

class Solution {
public:
  vector<int> flipMatchVoyage(TreeNode* root, vector<int>& voyage) {
    vector<int> flips;
    int pos = 0;
    solve(root, voyage, pos, flips);
    return flips;
  }
private:
  void solve(TreeNode* root, const vector<int>& voyage, int& pos, vector<int>& flips) {
    if (!root) return;
    if (root->val != voyage.at(pos)) {
      flips.clear();
      flips.push_back(-1);
      return;
    }
    if (root->left && root->left->val != voyage.at(pos + 1)) {
      swap(root->left, root->right);
      flips.push_back(root->val);
    }
    ++pos;
    solve(root->left, voyage, pos, flips);
    solve(root->right, voyage, pos, flips);   
  }
};

# Author: Huahua, 60 ms
class Solution:
  def flipMatchVoyage(self, root, voyage):
    self.pos = 0
    self.flips = []
    def solve(root):
      if not root: return      
      if root.val != voyage[self.pos]:
        self.flips = [-1]
        return
      if root.left and root.left.val != voyage[self.pos + 1]:
        root.left, root.right = root.right, root.left
        self.flips.append(root.val)
      self.pos += 1
      solve(root.left)
      solve(root.right)    
    solve(root)
    return self.flips

The post 花花酱 LeetCode 971. Flip Binary Tree To Match Preorder Traversal appeared first on Huahua's Tech Road.

Problem

Return any binary tree that matches the given preorder and postorder traversals.

Values in the traversals pre and post are distinct positive integers.

Example 1:

Input: pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
Output: [1,2,3,4,5,6,7]

Note:

• 1 <= pre.length == post.length <= 30
• pre[] and post[] are both permutations of 1, 2, ..., pre.length.
• It is guaranteed an answer exists. If there exists multiple answers, you can return any of them.

Solution: Recursion

pre = [(root) (left-child) (right-child)]

post = [(left-child) (right-child) (root)]

We need to recursively find the first node in pre.left-child from post.left-child

e.g.

pre = [(1), (2,4,5), (3,6,7)]

post = [(4,5,2), (6,7,3), (1)]

First element of left-child is 2 and the length of it is 3.

root = new TreeNode(1)
root.left = build((2,4,5), (4,5,2))
root.right = build((3,6,7), (6,7,3))

Time complexity: O(n^2)

Space complexity: O(n)

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post) {
    return constructFromPrePost(cbegin(pre), cend(pre), cbegin(post), cend(post));
  }
private:
  typedef vector<int>::const_iterator VIT;
  TreeNode* constructFromPrePost(VIT pre_l, VIT pre_r, VIT post_l, VIT post_r) {
    if (pre_l == pre_r) return nullptr;
    TreeNode* root = new TreeNode(*pre_l);
    ++pre_l;
    --post_r;
    if (pre_l == pre_r) return root;
    VIT post_m = next(find(post_l, post_r, *pre_l));
    VIT pre_m = pre_l + (post_m - post_l);
    root->left = constructFromPrePost(pre_l, pre_m, post_l, post_m);
    root->right = constructFromPrePost(pre_m, pre_r, post_m, post_r);
    return root;
  }
};

Time complexity: O(n^2)

Space complexity: O(n)

"""
Author: Huahua
Running time: 60 ms
"""
class Solution:
  def constructFromPrePost(self, pre, post):
    def build(i, j, n):
      if n <= 0: return None
      root = TreeNode(pre[i])
      if n == 1: return root
      k = j      
      while post[k] != pre[i + 1]: k += 1
      l = k - j + 1      
      root.left = build(i + 1, j, l)
      root.right = build(i + l + 1, k + 1, n - l - 1)
      return root
    return build(0, 0, len(pre))

Time complexity: O(n)

"""
Author: Huahua
Running time: 52 ms (beats 100%)
"""
class Solution:
  def constructFromPrePost(self, pre, post):    
    def build(i, j, n):
      if n <= 0: return None
      root = TreeNode(pre[i])
      if n == 1: return root
      k = index[pre[i + 1]]      
      l = k - j + 1      
      root.left = build(i + 1, j, l)
      root.right = build(i + l + 1, k + 1, n - l - 1)
      return root
    index = {}
    for i in range(len(pre)):
      index[post[i]] = i
    return build(0, 0, len(pre))

The post 花花酱 LeetCode 889. Construct Binary Tree from Preorder and Postorder Traversal appeared first on Huahua's Tech Road.

Given an n-ary tree, return the postorder traversal of its nodes’ values.

For example, given a 3-ary tree:

Return its postorder traversal as: [5,6,3,2,4,1].

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

Solution 1: Recursive

// Author: Huahua
// Running time: 44 ms
class Solution {
public:
  vector<int> postorder(Node* root) {
    vector<int> ans;
    postorder(root, ans);
    return ans;
  }
private:
  void postorder(Node* root, vector<int>& ans) {
    if (!root) return;
    for (auto child : root->children)
      postorder(child, ans);
    ans.push_back(root->val);
  }
};

Solution 2: Iterative

// Author: Huahua
// Running time: 44 ms
class Solution {
public:
  vector<int> postorder(Node* root) {
   if (!root) return {};
    vector<int> ans;
    stack<Node*> s;
    s.push(root);
    while (!s.empty()) {
      const Node* node = s.top(); s.pop();      
      ans.push_back(node->val);
      for (auto child : node->children)
        s.push(child);      
    }
    reverse(begin(ans), end(ans));
    return ans;
  }
};

Related Problems

• 花花酱 LeetCode 589. N-ary Tree Preorder Traversal
• 花花酱 LeetCode 145. Binary Tree Postorder Traversal
• 花花酱 LeetCode 102. Binary Tree Level Order Traversal

The post 花花酱 LeetCode 590. N-ary Tree Postorder Traversal 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.

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

Solution 1: BFS O(n)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
        vector<vector<int>> ans;
        vector<TreeNode*> curr,next;
        curr.push_back(root);
        while(!curr.empty()) {
            ans.push_back({});
            for(TreeNode* node : curr) {
                ans.back().push_back(node->val);
                if(node->left) next.push_back(node->left);
                if(node->right) next.push_back(node->right);
            }
            curr.swap(next);
            next.clear();
        }
        return ans;
    }
};

Solution 2: DFS O(n)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        DFS(root, 0 /* depth */, ans);
        return ans;
    }
private:
    void DFS(TreeNode* root, int depth, vector<vector<int>>& ans) {
        if(!root) return;
        // Works with pre/in/post order
        while(ans.size()<=depth) ans.push_back({});
        ans[depth].push_back(root->val); // pre-order
        DFS(root->left, depth+1, ans);        
        DFS(root->right, depth+1, ans);   
    }
};

The post 花花酱 LeetCode 102. Binary Tree Level Order Traversal appeared first on Huahua's Tech Road.