You are given the root of a binary search tree and an array queries of size n consisting of positive integers.

Find a 2D array answer of size n where answer[i] = [mini, maxi]:

• mini is the largest value in the tree that is smaller than or equal to queries[i]. If a such value does not exist, add -1 instead.
• maxi is the smallest value in the tree that is greater than or equal to queries[i]. If a such value does not exist, add -1 instead.

Return the array answer.

Example 1:

Input: root = [6,2,13,1,4,9,15,null,null,null,null,null,null,14], queries = [2,5,16]
Output: [[2,2],[4,6],[15,-1]]
Explanation: We answer the queries in the following way:
- The largest number that is smaller or equal than 2 in the tree is 2, and the smallest number that is greater or equal than 2 is still 2. So the answer for the first query is [2,2].
- The largest number that is smaller or equal than 5 in the tree is 4, and the smallest number that is greater or equal than 5 is 6. So the answer for the second query is [4,6].
- The largest number that is smaller or equal than 16 in the tree is 15, and the smallest number that is greater or equal than 16 does not exist. So the answer for the third query is [15,-1].

Example 2:

Input: root = [4,null,9], queries = [3]
Output: [[-1,4]]
Explanation: The largest number that is smaller or equal to 3 in the tree does not exist, and the smallest number that is greater or equal to 3 is 4. So the answer for the query is [-1,4].

Constraints:

• The number of nodes in the tree is in the range [2, 105].
• 1 <= Node.val <= 106
• n == queries.length
• 1 <= n <= 105
• 1 <= queries[i] <= 106

Solution: Convert to sorted array

Since we don’t know whether the tree is balanced or not, the safest and easiest way is to convert the tree into a sorted array using inorder traversal. Or just any traversal and sort the array later on.

Once we have a sorted array, we can use lower_bound / upper_bound to query.

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {    
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      vals.push_back(root->val);
      inorder(root->right);
    };
    
    inorder(root);
    
    vector<vector<int>> ans;
    for (const int q : queries) {
      vector<int> cur{-1, -1};
      auto lit = upper_bound(begin(vals), end(vals), q);
      if (lit != begin(vals))
        cur[0] = *(prev(lit));
      auto rit = lower_bound(begin(vals), end(vals), q);
      if (rit != end(vals))
        cur[1] = *rit;      
      ans.push_back(std::move(cur));
    }
    return ans;
  }
};

One binary search per query.

// Author: Huahua
class Solution {
public:
  vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {    
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      if (vals.empty() || root->val > vals.back()) vals.push_back(root->val);
      inorder(root->right);
    };
    
    inorder(root);
    
    vector<vector<int>> ans;
    for (const int q : queries) {
      vector<int> cur{-1, -1};      
      auto it = lower_bound(begin(vals), end(vals), q);
      if (it != end(vals) && *it == q)
        cur[0] = cur[1] = q;
      else {
        if (it != begin(vals)) cur[0] = *prev(it);
        if (it != end(vals)) cur[1] = *it;        
      }
      ans.push_back(std::move(cur));
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2476. Closest Nodes Queries in a Binary Search Tree appeared first on Huahua's Tech Road.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example 1:

Input: head = [-10,-3,0,5,9]
Output: [0,-3,9,-10,null,5]
Explanation: One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.

Example 2:

Input: head = []
Output: []

Example 3:

Input: head = [0]
Output: [0]

Example 4:

Input: head = [1,3]
Output: [3,1]

Constraints:

• The number of nodes in head is in the range [0, 2 * 104].
• -105 <= Node.val <= 105

Solution 1: Recursion w/ Fast + Slow Pointers

For each sublist, use fast/slow pointers to find the mid and build the tree.

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

// Author: Huahua
class Solution {
public:
  TreeNode *sortedListToBST(ListNode *head) {
    function<TreeNode*(ListNode*, ListNode*)> build 
      = [&](ListNode* head, ListNode* tail) -> TreeNode* {
      if (!head || head == tail) return nullptr;
      ListNode *fast = head, *slow = head;
      while (fast != tail && fast->next != tail) {
        slow = slow->next;
        fast = fast->next->next;
      }
      TreeNode *root = new TreeNode(slow->val);
      root->left = build(head, slow);
      root->right = build(slow->next, tail);
      return root;
    };
    return build(head, nullptr);
  }
};

The post 花花酱 LeetCode 109. Convert Sorted List to Binary Search Tree appeared first on Huahua's Tech Road.

Given a binary search tree, return a balanced binary search tree with the same node values.

A binary search tree is balanced if and only if the depth of the two subtrees of every node never differ by more than 1.

If there is more than one answer, return any of them.

Example 1:

Input: root = [1,null,2,null,3,null,4,null,null]
Output: [2,1,3,null,null,null,4]
Explanation: This is not the only correct answer, [3,1,4,null,2,null,null] is also correct.

Constraints:

• The number of nodes in the tree is between 1 and 10^4.
• The tree nodes will have distinct values between 1 and 10^5.

Solution: Inorder + recursion

Use inorder traversal to collect a sorted array from BST. And then build a balanced BST from this sorted array in O(n) time.

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

// Author: Huahua
class Solution {
public:
  TreeNode* balanceBST(TreeNode* root) {
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      vals.push_back(root->val);
      inorder(root->right);
    };
    
    function<TreeNode*(int, int)> build = [&](int l, int r) {
      if (l > r) return (TreeNode*)nullptr;
      int m = l + (r - l) / 2;
      auto root = new TreeNode(vals[m]);
      root->left = build(l, m - 1);
      root->right = build(m + 1, r);
      return root;
    };
    
    inorder(root);
    return build(0, vals.size() - 1);
  }
};

The post 花花酱 LeetCode 1382. Balance a Binary Search Tree appeared first on Huahua's Tech Road.

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example:

Given the sorted array: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5

Solution: Recursion

Recursively build a BST for a given range.

def build(nums, l, r):
if l > r: return None
m = l + (r – l) / 2
root = TreeNode(nums[m])
root.left = build(nums, l, m – 1)
root.right = build(nums, m + 1, r)
return root

return build(nums, 0, len(nums) – 1)

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

// Author: Huahua
class Solution {
public:
  TreeNode* sortedArrayToBST(vector<int>& nums) {
    function<TreeNode*(int l, int r)> build = [&](int l, int r) {
      if (l > r) return static_cast<TreeNode*>(nullptr);      
      int m = l + (r - l) / 2;
      TreeNode* root = new TreeNode(nums[m]);
      root->left = build(l, m - 1);
      root->right = build(m + 1, r);
      return root;
    };
    return build(0, nums.size() - 1);
  }
};

// Author: Huahua
class Solution {
  public TreeNode sortedArrayToBST(int[] nums) {
    return buildBST(nums, 0, nums.length - 1);
  }
  
  private TreeNode buildBST(int[] nums, int l, int r) {
    if (l > r) return null;
    int m = l + (r - l) / 2;
    TreeNode root = new TreeNode(nums[m]);
    root.left = buildBST(nums, l, m - 1);
    root.right = buildBST(nums, m + 1, r);
    return root;
  }
}

# Author: Huahua
class Solution:
  def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
    def buildBST(l: int, r: int) -> TreeNode:
      if l > r: return None
      m = l + (r - l) // 2
      root = TreeNode(nums[m])
      root.left = buildBST(l, m - 1)
      root.right = buildBST(m + 1, r)
      return root
    return buildBST(0, len(nums) - 1)

// Author: Huahua
var sortedArrayToBST = function(nums) {
  var buildBST = function(l, r) {    
    if (l > r) return null;
    let m = l + Math.floor((r - l) / 2);
    let root = new TreeNode(nums[m]);
    root.left = buildBST(l, m - 1);
    root.right = buildBST(m + 1, r);
    return root;
  }
  return buildBST(0, nums.length - 1);
};

The post 花花酱 LeetCode 108. Convert Sorted Array to Binary Search Tree appeared first on Huahua's Tech Road.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Given binary search tree:  root = [6,2,8,0,4,7,9,null,null,3,5]

Example 1:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Explanation: The LCA of nodes 2 and 8 is 6.

Example 2:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

Note:

• All of the nodes’ values will be unique.
• p and q are different and both values will exist in the BST.

Solution: Recursion

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

// Author: Huahua
class Solution {
public:
  TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {    
    if (p->val < root->val && q->val < root->val) 
      return lowestCommonAncestor(root->left, p, q);
    if (p->val > root->val && q->val > root->val)
      return lowestCommonAncestor(root->right, p, q);
    return root;
  }
};

The post 花花酱 LeetCode 235. Lowest Common Ancestor of a Binary Search Tree 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.

Given an array of integers nums and a positive integer k, find whether it’s possible to divide this array into sets of k consecutive numbers
Return True if its possibleotherwise return False.

Example 1:

Input: nums = [1,2,3,3,4,4,5,6], k = 4
Output: true
Explanation: Array can be divided into [1,2,3,4] and [3,4,5,6].

Example 2:

Input: nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
Output: true
Explanation: Array can be divided into [1,2,3] , [2,3,4] , [3,4,5] and [9,10,11].

Example 3:

Input: nums = [3,3,2,2,1,1], k = 3
Output: true

Example 4:

Input: nums = [1,2,3,4], k = 3
Output: false
Explanation: Each array should be divided in subarrays of size 3.

Constraints:

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^9
• 1 <= k <= nums.length

Solution: BST + Greedy

Start from the smallest available number and find k consecutive numbers.

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

// Author: Huahua
class Solution {
public:
  bool isPossibleDivide(vector<int>& nums, int k) {
    if (nums.size() % k) return false;
    map<int, int> m;
    for (int num : nums) ++m[num];
    while (m.size()) {
      const int s = m.cbegin()->first;
      for (int i = 0; i < k; ++i) {
        auto it = m.find(s + i);
        if (it == m.cend()) return false;
        if (--it->second == 0) m.erase(it);
      }
    }
    return true;
  }
};

// Author: Huahua
class Solution {
public:
  bool isPossibleDivide(vector<int>& nums, int k) {
    if (nums.size() % k) return false;
    map<int, int> m;
    for (int num : nums) ++m[num];
    while (m.size()) {
      auto it = m.begin();
      const int s = it->first;
      for (int i = 0; i < k; ++i, ++it) {
        if (it->first != s + i) return false;
        if (--it->second == 0) m.erase(it);        
      }
    }
    return true;
  }
};

Solution 2: HashTable

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

class Solution {
public:
  bool isPossibleDivide(vector<int>& nums, int k) {
    if (nums.size() % k) return false;
    unordered_map<int, int> m;
    for (int num : nums) ++m[num];
    queue<int> starts;
    for (auto [n, f] : m)
      if (!m.count(n - 1)) starts.push(n);
    while (!starts.empty()) {
      int s = starts.front();
      starts.pop();
      for (int t = s + k - 1; t >= s; t--) {
        if (m[t] < m[s]) return false;
        if ((m[t] -= m[s]) == 0) {
          m.erase(t);
          if (m.count(t + 1)) starts.push(t + 1);
        }
      }
    }
    return true;
  }
};

Related Problems

• https://zxi.mytechroad.com/blog/hashtable/leetcode-128-longest-consecutive-sequence/

The post 花花酱 LeetCode 1296. Divide Array in Sets of K Consecutive Numbers appeared first on Huahua's Tech Road.

Note: 
You may assume k is always valid, 1 ≤ k ≤ BST’s total elements.

Example 1:

Input: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
Output: 1

Example 2:

Input: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
Output: 3

Follow up:
What if the BST is modified (insert/delete operations) often and you need to find the kth smallest frequently? How would you optimize the kthSmallest routine?

Solution: Inorder traversal

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

class Solution {
public:
  int kthSmallest(TreeNode* root, int k) {
    return inorder(root, k);
  }
private:
  int inorder(TreeNode* root, int& k) {
    if (!root) return -1;
    int x = inorder(root->left, k);
    if (k == 0) return x;
    if (--k == 0) return root->val;
    return inorder(root->right, k);
  }
};

The post 花花酱 LeetCode 230. Kth Smallest Element in a BST appeared first on Huahua's Tech Road.

Binary tree is one of the most frequently asked question type during interview.

二叉树是面试中经常会问到的问题。

The candidate needs to understand the recursively defined TreeNode and solve the problem through recursion.

面试者需要理解递归定义的TreeNode数据类型，并且通过使用递归的方式来解决问题。

The post 花花酱 LeetCode Binary Trees 二叉树 SP12 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 an array A, partition it into two (contiguous) subarrays left and right so that:

• Every element in left is less than or equal to every element in right.
• left and right are non-empty.
• left has the smallest possible size.

Return the length of left after such a partitioning.  It is guaranteed that such a partitioning exists.

Example 1:

Input: [5,0,3,8,6]
Output: 3
Explanation: left = [5,0,3], right = [8,6]

Input: [1,1,1,0,6,12]
Output: 4
Explanation: left = [1,1,1,0], right = [6,12]

Note:

1. 2 <= A.length <= 30000
2. 0 <= A[i] <= 10^6
3. It is guaranteed there is at least one way to partition A as described.

Solution 1: BST

Time complexity: O(nlogn)

Space complexity: O(n)

// Author: Huahua, 100 ms
class Solution {
public:
  int partitionDisjoint(vector<int>& A) {
    multiset<int> s(begin(A) + 1, end(A));
    int left_max = A[0];
    for (int i = 1; i < A.size(); ++i) {      
      if (*begin(s) >= left_max) return i;
      s.erase(s.equal_range(A[i]).first);
      left_max = max(left_max, A[i]);      
    }
    return -1;
  }
};

Solution 2: Greedy

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua, 28 ms
class Solution {
public:
  int partitionDisjoint(vector<int>& A) {    
    int left_max = A[0];
    int cur_max = A[0];
    int left_len = 1;
    for (int i = 1; i < A.size(); ++i) {
      if (A[i] < left_max) {
        left_max = cur_max;
        left_len = i + 1;        
      } else {
        cur_max = max(cur_max, A[i]);
      }
    }
    return left_len;
  }
};

The post 花花酱 LeetCode 915. Partition Array into Disjoint Intervals appeared first on Huahua's Tech Road.

In an exam room, there are N seats in a single row, numbered 0, 1, 2, ..., N-1.

When a student enters the room, they must sit in the seat that maximizes the distance to the closest person.  If there are multiple such seats, they sit in the seat with the lowest number.  (Also, if no one is in the room, then the student sits at seat number 0.)

Return a class ExamRoom(int N) that exposes two functions: ExamRoom.seat() returning an int representing what seat the student sat in, and ExamRoom.leave(int p) representing that the student in seat number p now leaves the room.  It is guaranteed that any calls to ExamRoom.leave(p) have a student sitting in seat p.

Example 1:

Input: ["ExamRoom","seat","seat","seat","seat","leave","seat"], [[10],[],[],[],[],[4],[]]
Output: [null,0,9,4,2,null,5]
Explanation:
ExamRoom(10) -> null
seat() -> 0, no one is in the room, then the student sits at seat number 0.
seat() -> 9, the student sits at the last seat number 9.
seat() -> 4, the student sits at the last seat number 4.
seat() -> 2, the student sits at the last seat number 2.
leave(4) -> null
seat() -> 5, the student​​​​​​​ sits at the last seat number 5.

​​​​Note:

1. 1 <= N <= 10^9
2. ExamRoom.seat() and ExamRoom.leave() will be called at most 10^4 times across all test cases.
3. Calls to ExamRoom.leave(p) are guaranteed to have a student currently sitting in seat number p.

Solution: BST

Use a BST (ordered set) to track the current seatings.

Time Complexity:

init: O(1)

seat: O(P)

leave: O(logP)

Space complexity: O(P)

// Author: Huahua
// Running time: 24 ms
class ExamRoom {
public:
  ExamRoom(int N): N_(N) {}

  int seat() {
    int p = 0;
    int max_dist = s_.empty() ? 0 : *s_.begin();
    auto left = s_.begin();    
    auto right = left;
    while (left != s_.end()) {
      ++right;
      int l = *left;
      int r = right != s_.end() ? *right : (2 * (N_ - 1) - *left);      
      int d = (r - l) / 2;      
      if (d > max_dist) {
        max_dist = d;
        p = l + d;
      }
      left = right;
    }    
    s_.insert(p);
    return p;
  }

  void leave(int p) {
    s_.erase(p);
  }

private:
  const int N_;
  set<int> s_;
};

The post 花花酱 LeetCode 855. Exam Room appeared first on Huahua's Tech Road.

Given the root node of a binary search tree (BST) and a value to be inserted into the tree, insert the value into the BST. Return the root node of the BST after the insertion. It is guaranteed that the new value does not exist in the original BST.

Note that there may exist multiple valid ways for the insertion, as long as the tree remains a BST after insertion. You can return any of them.

For example,

Given the tree:
        4
       / \
      2   7
     / \
    1   3
And the value to insert: 5

You can return this binary search tree:

4
       /   \
      2     7
     / \   /
    1   3 5

This tree is also valid:

5
       /   \
      2     7
     / \   
    1   3
         \
          4

Solution: Recursion

Time complexity: O(logn ~ n)

Space complexity: O(logn ~ n)

// Author: Huahua
// Running time: 52 ms
class Solution {
public:
  TreeNode* insertIntoBST(TreeNode* root, int val) {
    if (root == nullptr) return new TreeNode(val);
    if (val > root->val)
      root->right = insertIntoBST(root->right, val);
    else
      root->left = insertIntoBST(root->left, val);
    return root;
  }
};

The post 花花酱 LeetCode 701. Insert into a Binary Search Tree appeared first on Huahua's Tech Road.

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Your KthLargest class will have a constructor which accepts an integer k and an integer array nums, which contains initial elements from the stream. For each call to the method KthLargest.add, return the element representing the kth largest element in the stream.

Example:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

Note: 
You may assume that nums‘ length ≥ k-1 and k ≥ 1.

Solution: BST / Min Heap

Time complexity: O(nlogk)

Space complexity: O(k)

C++ / BST

// Author: Huahua
// Running time: 32 ms
class KthLargest {
public:
  KthLargest(int k, vector<int> nums): k_(k) {
    for (int num : nums)
      add(num);
  }

  int add(int val) {    
    s_.insert(val);
    if (s_.size() > k_)
      s_.erase(s_.begin());
    return *s_.begin();
  }
private:
  const int k_;  
  multiset<int> s_;
};

C++ / Min Heap

// Author: Huahua
// Running time: 28 ms
class KthLargest {
public:
  KthLargest(int k, vector<int> nums): k_(k) {    
    for (int num : nums)
      add(num);
  }

  int add(int val) {    
    s_.push(val);
    if (s_.size() > k_)
      s_.pop();
    return s_.top();
  }
private:
  const int k_;  
  priority_queue<int, vector<int>, greater<int>> s_; // min heap
};

The post 花花酱 LeetCode 703. Kth Largest Element in a Stream appeared first on Huahua's Tech Road.

Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node’s value equals the given value. Return the subtree rooted with that node. If such node doesn’t exist, you should return NULL.

For example,

Given the tree:
        4
       / \
      2   7
     / \
    1   3

And the value to search: 2

You should return this subtree:

      2     
     / \   
    1   3

In the example above, if we want to search the value 5, since there is no node with value 5, we should return NULL.

Solution: Recursion

Time complexity: O(logn ~ n)

Space complexity: O(logn ~ n)

// Author: Huahua
// Running time: 24 ms
class Solution {
public:
  TreeNode* searchBST(TreeNode* root, int val) {
    if (root == nullptr) return nullptr;
    if (val == root->val) 
      return root;
    else if (val > root->val) 
      return searchBST(root->right, val);
    return searchBST(root->left, val);
  }
};

The post 花花酱 LeetCode 700. Search in a Binary Search Tree appeared first on Huahua's Tech Road.