Definition of a complete binary tree from Wikipedia:
In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2^h nodes inclusive at the last level h.

Example 1:

Input: [1,2,3,4,5,6]
Output: true
Explanation: Every level before the last is full (ie. levels with node-values {1} and {2, 3}), and all nodes in the last level ({4, 5, 6}) are as far left as possible.

Example 2:

Input: [1,2,3,4,5,null,7]
Output: false
Explanation: The node with value 7 isn't as far left as possible.

Note:

1. The tree will have between 1 and 100 nodes.

Solution:

Level order traversal, if any nodes appears after a missing node then the tree is not a perfect binary tree.

Time complexity: O(n)

Space complexity: O(n)

class Solution {
public:
  bool isCompleteTree(TreeNode* root) {
    if (!root) return true;
    queue<TreeNode> q;
    q.push(root);
    bool missing = false;
    while (!q.empty()) {
      auto size = q.size();      
      while (size--) {
        auto node = q.front(); q.pop();        
        if (node) {
          if (missing) return false;
          q.push(node-&gt;left);
          q.push(node-&gt;right);
        } else {
          missing = true;
        }
      }      
    }
    return true;
  }
};

class Solution:
  def isCompleteTree(self, root):
    if not root: return True
    q = collections.deque([root])
    missing = False
    while q:
      size = len(q)    
      while size > 0:
        size -= 1
        node = q.popleft()
        if node:
          if missing: return False
          q.append(node.left)
          q.append(node.right)
        else:
          missing = True
    return True

The post 花花酱 LeetCode 958. Check Completeness of a Binary Tree appeared first on Huahua's Tech Road.

Problem

Given a balanced parentheses string S, compute the score of the string based on the following rule:

• () has score 1
• AB has score A + B, where A and B are balanced parentheses strings.
• (A) has score 2 * A, where A is a balanced parentheses string.

Input: "()"
Output: 1

Input: "(())"
Output: 2

Input: "()()"
Output: 2

Input: "(()(()))"
Output: 6

// Author: Huahua
// Running time: 4ms
class Solution {
public:
  int scoreOfParentheses(string S) {
    return score(S, 0, S.length() - 1);
  }
private:
  int score(const string& S, int l, int r) {    
    if (r - l == 1) return 1; // "()"
    int b = 0;
    for (int i = l; i < r; ++i) {
      if (S[i] == '(') ++b;
      if (S[i] == ')') --b;
      if (b == 0) // balanced
        // score("(A)(B)") = score("(A)") + score("(B)")
        return score(S, l, i) + score(S, i + 1, r);    
    }
    // score("(A)") = 2 * score("A")
    return 2 * score(S, l + 1, r - 1); 
  }
};

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int scoreOfParentheses(string S) {
    int ans = 0;
    int d = -1;
    for (int i = 0; i < S.length(); ++i) {
      d += S[i] == '(' ? 1 : -1;
      if (S[i] == '(' && S[i + 1] == ')')
        ans += 1 << d;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 856. Score of Parentheses appeared first on Huahua's Tech Road.