Example 1:

Input: nums = ["01","10"]
Output: "11"
Explanation: "11" does not appear in nums. "00" would also be correct.

Example 2:

Input: nums = ["00","01"]
Output: "11"
Explanation: "11" does not appear in nums. "10" would also be correct.

Example 3:

Input: nums = ["111","011","001"]
Output: "101"
Explanation: "101" does not appear in nums. "000", "010", "100", and "110" would also be correct.

Constraints:

• n == nums.length
• 1 <= n <= 16
• nums[i].length == n
• nums[i] is either '0' or '1'.
• All the strings of nums are unique.

Solution 1: Hashtable

We can use bitset to convert between integer and binary string.

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

// Author: Huahua
class Solution {
public:
  string findDifferentBinaryString(vector<string>& nums) {
    const int n = nums.size();
    unordered_set<int> seen(1 << n);
    for (const string& num : nums)
      seen.insert(bitset<16>(num).to_ulong());
    for (int i = 0; i < 1 << n; ++i)
      if (!seen.count(i)) return bitset<16>(i).to_string().substr(16 - n);
    return "";
  }
};

Solution 2: One bit a time

Let ans[i] = ‘1’ – nums[i][i], s.t. ans is at least one bit different from any strings.

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

// Author: Huahua
class Solution {
public:
  string findDifferentBinaryString(vector<string>& nums) {    
    const int n = nums.size();
    string ans(n, '0');
    for (int i = 0; i < n; ++i)
      ans[i] = '1' - nums[i][i] + '0';
    return ans;
  }
};

The post 花花酱 LeetCode 1980. Find Unique Binary String appeared first on Huahua's Tech Road.

The integer division should truncate toward zero, which means losing its fractional part. For example, 8.345 would be truncated to 8, and -2.7335 would be truncated to -2.

Return the quotient after dividing dividend by divisor.

Note: Assume we are dealing with an environment that could only store integers within the 32-bit signed integer range: [−231, 231 − 1]. For this problem, if the quotient is strictly greater than 231 - 1, then return 231 - 1, and if the quotient is strictly less than -231, then return -231.

Example 1:

Input: dividend = 10, divisor = 3
Output: 3
Explanation: 10/3 = 3.33333.. which is truncated to 3.

Example 2:

Input: dividend = 7, divisor = -3
Output: -2
Explanation: 7/-3 = -2.33333.. which is truncated to -2.

Example 3:

Input: dividend = 0, divisor = 1
Output: 0

Example 4:

Input: dividend = 1, divisor = 1
Output: 1

Constraints:

• -231 <= dividend, divisor <= 231 - 1
• divisor != 0

Solution: Binary / Bit Operation

The answer can be represented in binary format.

a / b = c
a >= b *  Σ(d_i*2ⁱ)
c = Σ(d_i*2ⁱ)

e.g. 1: 10 / 3
=> 10 >= 3*(2¹ + 2⁰) = 3 * (2 + 1) = 9
ans = 2¹ + 2⁰ = 3

e.g. 2: 100 / 7
=> 100 >= 7*(2³ + 2²+2¹) = 7 * (8 + 4 + 2) = 7 * 14 = 98
ans = 2³+2²+2¹=8+4+2=14

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

// Author: Huahua
class Solution {
public:
  int divide(int A, int B) {
    if (B == INT_MIN)
      return A == INT_MIN ? 1 : 0;
    if (A == INT_MIN) {
      if (B == -1) return INT_MAX;
      return B > 0 ? divide(A + B, B) - 1 : divide(A - B, B) + 1;
    }    
    int a = abs(A);
    int b = abs(B);
    int ans = 0;
    for (int x = 31; x >= 0; --x)
      if (a >> x >= b)
        ans += 1 << x, a -= b << x;
    return (A > 0) == (B > 0) ? ans : -ans;
  }
};

The post 花花酱 LeetCode 29. Divide Two Integers appeared first on Huahua's Tech Road.

• Operation 1: If the number contains the substring "00", you can replace it with "10".
  • For example, "00010" -> "10010“
• Operation 2: If the number contains the substring "10", you can replace it with "01".
  • For example, "00010" -> "00001"

Return the maximum binary string you can obtain after any number of operations. Binary string x is greater than binary string y if x‘s decimal representation is greater than y‘s decimal representation.

Example 1:

Input: binary = "000110"
Output: "111011"
Explanation: A valid transformation sequence can be:
"000110" -> "000101" 
"000101" -> "100101" 
"100101" -> "110101" 
"110101" -> "110011" 
"110011" -> "111011"

Example 2:

Input: binary = "01"
Output: "01"
Explanation: "01" cannot be transformed any further.

Constraints:

• 1 <= binary.length <= 105
• binary consist of '0' and '1'.

Solution: Greedy + Counting

Leading 1s are good, no need to change them.
For the rest of the string
1. Apply operation 2 to make the string into 3 parts, leading 1s, middle 0s and tailing 1s.
e.g. 11010101 => 11001101 => 11001011 => 11000111
2. Apply operation 1 to make flip zeros to ones except the last one.
e.g. 11000111 => 11100111 => 11110111

There will be only one zero (if the input string is not all 1s) is the final largest string, the position of the zero is leading 1s + zeros – 1.

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

class Solution {
public:
  string maximumBinaryString(string s) {
    const int n = s.length();
    int l = 0;
    int z = 0;
    for (char& c : s) {
      if (c == '0') {
        ++z;
      } else if (z == 0) { // leading 1s      
        ++l;
      }
      c = '1';
    }
    if (l != n) s[l + z - 1] = '0';
    return s;
  }
};

The post 花花酱 LeetCode 1702. Maximum Binary String After Change appeared first on Huahua's Tech Road.

Your task is to form an integer array nums from an initial array of zeros arr that is the same size as nums.

Return the minimum number of function calls to make nums from arr.

The answer is guaranteed to fit in a 32-bit signed integer.

Example 1:

Input: nums = [1,5]
Output: 5
Explanation: Increment by 1 (second element): [0, 0] to get [0, 1] (1 operation).
Double all the elements: [0, 1] -> [0, 2] -> [0, 4] (2 operations).
Increment by 1 (both elements)  [0, 4] -> [1, 4] -> [1, 5] (2 operations).
Total of operations: 1 + 2 + 2 = 5.

Example 2:

Input: nums = [2,2]
Output: 3
Explanation: Increment by 1 (both elements) [0, 0] -> [0, 1] -> [1, 1] (2 operations).
Double all the elements: [1, 1] -> [2, 2] (1 operation).
Total of operations: 2 + 1 = 3.

Example 3:

Input: nums = [4,2,5]
Output: 6
Explanation: (initial)[0,0,0] -> [1,0,0] -> [1,0,1] -> [2,0,2] -> [2,1,2] -> [4,2,4] -> [4,2,5](nums).

Example 4:

Input: nums = [3,2,2,4]
Output: 7

Example 5:

Input: nums = [2,4,8,16]
Output: 8

Constraints:

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

Solution: count 1s

For 5 (101b), we can add 1s for 5 times which of cause isn’t the best way to generate 5, the optimal way is to [+1, *2, +1]. We have to add 1 for each 1 in the binary format. e.g. 11 (1011), we need 3x “+1” op, and 4 “*2” op. Fortunately, the “*2” can be shared/delayed, thus we just need to find the largest number.
e.g. [2,4,8,16]
[0, 0, 0, 0] -> [0, 0, 0, 1] -> [0, 0, 0, 2]
[0, 0, 0, 2] -> [0, 0, 1, 2] -> [0, 0, 2, 4]
[0, 0, 2, 4] -> [0, 1, 2, 4] -> [0, 2, 4, 8]
[0, 2, 4, 8] -> [1, 2, 4, 8] -> [2, 4, 8, 16]
ans = sum{count_1(arr_i)} + high_bit(max(arr_i))

Time complexity: O(n*log(max(arr_i))
Space complexity: O(1)

class Solution {
public:
  int minOperations(vector<int>& nums) {
    int ans = 0;
    int high = 0;
    for (int x : nums) {
      high = max(high, 31 - __builtin_clz(x | 1));
      ans += std::bitset<32>(x).count();
    }
    return ans + high;
  }
};

class Solution {
  public int minOperations(int[] nums) {
    int ans = 0;
    int high = 0;
    for (int x : nums) {
      int l = -1;
      while (x != 0) {        
        ans += x & 1;
        x >>= 1; 
        ++l;
      }
      high = Math.max(high, l);
    }
    return ans + high;
  }
}

class Solution:
  def minOperations(self, nums: List[int]) -> int:
    return sum(bin(x).count('1') for x in nums) + len(bin(max(nums))) - 3

The post 花花酱 LeetCode 1558. Minimum Numbers of Function Calls to Make Target Array appeared first on Huahua's Tech Road.

1. root.val == 0
2. If treeNode.val == x and treeNode.left != null, then treeNode.left.val == 2 * x + 1
3. If treeNode.val == x and treeNode.right != null, then treeNode.right.val == 2 * x + 2

Now the binary tree is contaminated, which means all treeNode.val have been changed to -1.

You need to first recover the binary tree and then implement the FindElements class:

• FindElements(TreeNode* root) Initializes the object with a contamined binary tree, you need to recover it first.
• bool find(int target) Return if the target value exists in the recovered binary tree.

Example 1:

Input
["FindElements","find","find"]
[[[-1,null,-1]],[1],[2]]
Output

[null,false,true]

Explanation FindElements findElements = new FindElements([-1,null,-1]); findElements.find(1); // return False findElements.find(2); // return True

Example 2:

Input
["FindElements","find","find","find"]
[[[-1,-1,-1,-1,-1]],[1],[3],[5]]
Output

[null,true,true,false]

Explanation FindElements findElements = new FindElements([-1,-1,-1,-1,-1]); findElements.find(1); // return True findElements.find(3); // return True findElements.find(5); // return False

Example 3:

Input
["FindElements","find","find","find","find"]
[[[-1,null,-1,-1,null,-1]],[2],[3],[4],[5]]
Output

[null,true,false,false,true]

Explanation FindElements findElements = new FindElements([-1,null,-1,-1,null,-1]); findElements.find(2); // return True findElements.find(3); // return False findElements.find(4); // return False findElements.find(5); // return True

Constraints:

• TreeNode.val == -1
• The height of the binary tree is less than or equal to 20
• The total number of nodes is between [1, 10^4]
• Total calls of find() is between [1, 10^4]
• 0 <= target <= 10^6

Solutoin 1: Recursion and HashSet

Time complexity: Recover O(n), find O(1)
Space complexity: O(n)

// Author: Huahua
class FindElements {
public:
  FindElements(TreeNode* root) {
    recover(root, 0);
  }

  bool find(int target) {
    return s_.count(target);
  }
private:
  unordered_set<int> s_;
  void recover(TreeNode* root, int val) {
    if (!root) return;
    root->val = val;
    s_.insert(val);
    recover(root->left, val * 2 + 1);
    recover(root->right, val * 2 + 2);
  }
};

Solution 2: Recursion and Binary format

The binary format of t = (target + 1) (from high bit to low bit, e.g. in reverse order) decides where to go at each node.
t % 2 == 1, go right, otherwise go left
t = t / 2 or t >>= 1

e.g. target = 13, t = 13 + 1 = 14
t = 14, t % 1 = 0, t / 2 = 7, left
t = 7, t % 1 = 1, t / 2 = 3, right
t = 3, t % 1 = 1, t / 2 = 1, right
13 => right, right, left 
0
 \
  2
    \
     6
   /
13

Time complexity: Recover O(n), find O(log|target|)
Space complexity: O(1)

// Author: Huahua
class FindElements {
public:
  FindElements(TreeNode* root): root_(root) {
    recover(root, 0);
  }

  bool find(int target) {    
    ++target;
    stack<bool> right;
    while (target != 1) {
      right.push(target & 1);
      target >>= 1;
    }
    
    TreeNode* node = root_;
    while (!right.empty() && node) {
      node = right.top() ? node->right : node->left;
      right.pop();
    }
    
    return node;
  }
private:
  TreeNode* root_;
  void recover(TreeNode* root, int val) {
    if (!root) return;
    root->val = val;    
    recover(root->left, val * 2 + 1);
    recover(root->right, val * 2 + 2);
  }
};

The post 花花酱 LeetCode 1261. Find Elements in a Contaminated Binary Tree appeared first on Huahua's Tech Road.

Given a set of distinct integers, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

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

Solution: Combination

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

Implemention 1: DFS

// Author: Huahua, running time: 4 ms
class Solution {
public:
  vector<vector<int>> subsets(vector<int>& nums) {
    vector<vector<int>> ans;
    vector<int> cur;
    for (int i = 0; i <= nums.size(); ++i)
      dfs(nums, i, 0, cur, ans);
    return ans;
  }
private:  
  void dfs(const vector<int>& nums, int n, int s, 
           vector<int>& cur, vector<vector<int>>& ans) {
    if (n == cur.size()) {
      ans.push_back(cur);
      return;
    }
    for (int i = s; i < nums.size(); ++i) {
      cur.push_back(nums[i]);
      dfs(nums, n, i + 1, cur, ans);
      cur.pop_back();
    }
  }
};

# Author: Huahua, running time: 60 ms
class Solution:
  def subsets(self, nums):
    ans = []
    def dfs(n, s, cur):
      if n == len(cur):
        ans.append(cur.copy())
        return
      for i in range(s, len(nums)):
        cur.append(nums[i])
        dfs(n, i + 1, cur)
        cur.pop()
    for i in range(len(nums) + 1):
      dfs(i, 0, [])
    return ans

Implementation 2: Binary

// Author: Huahua, running time: 4 ms
class Solution {
public:
  vector<vector<int>> subsets(vector<int>& nums) {
    const int n = nums.size();
    vector<vector<int>> ans;    
    for (int s = 0; s < 1 << n; ++s) {
      vector<int> cur;
      for (int i = 0; i < n; ++i)
        if (s & (1 << i)) cur.push_back(nums[i]);
      ans.push_back(cur);
    }
    return ans;
  }
};

# Author: Huahua, 40 ms
class Solution:
  def subsets(self, nums):
    n = len(nums)
    return [[nums[i] for i in range(n) if s & 1 << i > 0] for s in range(1 << n)]

The post 花花酱 LeetCode 78. Subsets appeared first on Huahua's Tech Road.

Starting with a positive integer N, we reorder the digits in any order (including the original order) such that the leading digit is not zero.

Return true if and only if we can do this in a way such that the resulting number is a power of 2.

Input: 1
Output: true

Input: 10
Output: false

Input: 16
Output: true

Input: 24
Output: false

<strong>Input: </strong><span id="example-input-5-1">46</span>
<strong>Output: </strong><span id="example-output-5">true</span>

Solution: HashTable

Compare the counter of digit string with that of all power of 2s.

e.g. 64 -> {4: 1, 6: 1} == 46 {4:1, 6: 1}

Time complexity: O(1)

Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  bool reorderedPowerOf2(int N) {    
    auto m = countMap(N);
    for (int i = 0; i < 31; ++i)
      if (m == countMap(1 << i)) return true;
    return false;
  }
private:
  map<int, int> countMap(int n) {
    map<int, int> m;
    while (n) {
      ++m[n % 10];
      n /= 10;
    }
    return m;
  }
};

The post 花花酱 LeetCode 869. Reordered Power of 2 appeared first on Huahua's Tech Road.

Given a positive integer N, find and return the longest distance between two consecutive 1’s in the binary representation of N.

If there aren’t two consecutive 1’s, return 0.

Example 1:

Input: 22
Output: 2
Explanation: 
22 in binary is 0b10110.
In the binary representation of 22, there are three ones, and two consecutive pairs of 1's.
The first consecutive pair of 1's have distance 2.
The second consecutive pair of 1's have distance 1.
The answer is the largest of these two distances, which is 2.

Example 2:

Input: 5
Output: 2
Explanation: 
5 in binary is 0b101.

Example 3:

Input: 6
Output: 1
Explanation: 
6 in binary is 0b110.

Example 4:

Input: 8
Output: 0
Explanation: 
8 in binary is 0b1000.
There aren't any consecutive pairs of 1's in the binary representation of 8, so we return 0.\

Note:

• 1 <= N <= 10^9

Solution: Bit

Time complexity: O(logN)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int binaryGap(int N) {
    int l = -1;
    int ans = 0;
    for (int i = 0; i < 31; ++i)
      if (N & (1 << i)) {
        if (l >= 0)
          ans = max(ans, i - l);
        l = i;
      }
    return ans;
  }
};

The post 花花酱 LeetCode 868. Binary Gap appeared first on Huahua's Tech Road.

Problem:

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

For example, you may serialize the following tree

1
   / \
  2   3
     / \
    4   5

as "[1,2,3,null,null,4,5]", just the same as how LeetCode OJ serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.

Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/

Idea:

Recursion

Time Complexity O(n)

Solution 1: ASCII

// Author: Huahua
// Running time: 39 ms
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }
private:
    void serialize(TreeNode* root, ostringstream& out) {
        if (!root) {
            out << "# ";
            return;
        }        
        out << root->val << " ";
        serialize(root->left, out);
        serialize(root->right, out);
    }
    
    TreeNode* deserialize(istringstream& in) {
        string val;
        in >> val;
        if (val == "#") return nullptr;        
        TreeNode* root = new TreeNode(stoi(val));        
        root->left = deserialize(in);
        root->right = deserialize(in);        
        return root;
    }
};

Solution 2: Binary

// Author: Huahua
// Running time: 23 ms (beat 98.07%)
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }
private:
    enum STATUS {
        ROOT_NULL = 0x0,
        ROOT = 0x1,
        LEFT = 0x2,
        RIGHT = 0x4
    };
    
    void serialize(TreeNode* root, ostringstream& out) {
        char status = 0;
        if (root) status |= ROOT;
        if (root && root->left) status |= LEFT;
        if (root && root->right) status |= RIGHT;
        out.write(&status, sizeof(char));        
        if (!root) return;
        out.write(reinterpret_cast<char*>(&(root->val)), sizeof(root->val));
        if (root->left) serialize(root->left, out);
        if (root->right) serialize(root->right, out);
    }
    
    TreeNode* deserialize(istringstream& in) {
        char status;
        in.read(&status, sizeof(char));
        if (!status & ROOT) return nullptr;
        auto root = new TreeNode(0);
        in.read(reinterpret_cast<char*>(&root->val), sizeof(root->val));        
        root->left = (status & LEFT) ? deserialize(in) : nullptr;
        root->right = (status & RIGHT) ? deserialize(in) : nullptr;
        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));

// Author: Huahua
// Running time: 23 ms (<98.13%)
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string s;
        serialize(root, s);
        return s;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) { 
        int pos = 0;
        return deserialize(data, pos);
    }
private:
    enum STATUS {
        ROOT_NULL = 0x0,
        ROOT = 0x1,
        LEFT = 0x2,
        RIGHT = 0x4
    };
    
    void serialize(TreeNode* root, string& s) {
        char status = ROOT_NULL;
        if (root) status |= ROOT;
        if (root && root->left) status |= LEFT;
        if (root && root->right) status |= RIGHT;
        s.push_back(status);
        if (!root) return;
        s.append(reinterpret_cast<char*>(&root->val), sizeof(root->val));
        if (root->left) serialize(root->left, s);
        if (root->right) serialize(root->right, s);
    }
    
    TreeNode* deserialize(const string& s, int& pos) {
        char status = s[pos++];
        if (!status) return nullptr;
        TreeNode* root = new TreeNode(0);
        memcpy(&root->val, s.data() + pos, sizeof(root->val));
        pos += sizeof(root->val);  
        root->left = (status & LEFT) ? deserialize(s, pos) : nullptr;
        root->right = (status & RIGHT) ? deserialize(s, pos) : nullptr;
        return root;
    }
};

Related Problems

• LeetCode 449. Serialize and Deserialize BST

The post 花花酱 LeetCode 297. Serialize and Deserialize Binary Tree appeared first on Huahua's Tech Road.

Given a binary search tree and the lowest and highest boundaries as L and R, trim the tree so that all its elements lies in [L, R] (R >= L). You might need to change the root of the tree, so the result should return the new root of the trimmed binary search tree.

Example 1:

Input:
    1
   / \
  0   2

  L = 1
  R = 2

Output: 
    1
      \
       2

Example 2:

Input:
    3
   / \
  0   4
   \
    2
   /
  1

  L = 1
  R = 3

Output:
      3
     / 
   2   
  /
 1

This problem can be solved with recursion

There 3 cases in total depends on the root value and L, R

Time complexity: O(n)

Space complexity: O(1)

Solution:

// Author: Huahua
class Solution {
public:
    // No cleanup -> memory leak 
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        if(!root) return nullptr;
        // val not in range, return the left/right subtrees
        if(root->val < L) return trimBST(root->right, L, R);
        if(root->val > R) return trimBST(root->left, L, R);
        // val in [L, R], recusively trim left/right subtrees
        root->left = trimBST(root->left, L, R);
        root->right = trimBST(root->right, L, R);
        return root;
    }
};

The previous solution has potential memory leak for languages without garbage collection.

Here’s the full program to delete trimmed nodes.

// Author: Huahua
#include <iostream>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
 
class Solution {
public:
    
    // With cleanup -> no memory leak
    TreeNode*& trimBST(TreeNode*& root, int L, int R) {
        if(!root) return root;
        
        if(root->val < L) {            
            auto& result = trimBST(root->right, L, R);
            deleteTree(root->left);
            delete root;
            root=nullptr;
            return result;
        } else if(root->val > R) {
            auto& result = trimBST(root->left, L, R);
            deleteTree(root->right);
            delete root;
            root=nullptr;
            return result;
        } else {
            // recusively trim left/right subtrees
            root->left = trimBST(root->left, L, R);
            root->right = trimBST(root->right, L, R);
            return root;
        }
    }
    
    void deleteTree(TreeNode* &root) {
        if(!root) return;
        deleteTree(root->left);
        deleteTree(root->right);
        delete root;
        root=nullptr;
    }
};

void PrintTree(TreeNode* root) {
    if(!root) {
        cout<<"null ";
        return;
    };
    if(!root->left && !root->right) {
        cout<<root->val<<" ";
    } else {
        cout<<root->val<<" ";
        PrintTree(root->left);
        PrintTree(root->right);
    }
}


int main()
{
    TreeNode* root=new TreeNode(2);
    root->left=new TreeNode(1);
    root->right=new TreeNode(3);
    PrintTree(root);
    std::cout<<std::endl;
    
    TreeNode* t = Solution().trimBST(root, 3, 4);
    PrintTree(t);
    std::cout<<std::endl;

    // Original root was deleted
    PrintTree(root);
    std::cout<<std::endl;
    
    return 0;
}

Example output

2 1 3 
3 
null

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