Cacher is the code snippet organizer for pro developers

// ===================================================================
// recursive version
int minimum_depth(TreeNode *root) {
    if(!root) return 0;
    if(!root->left && !root->right) return 1;
    int minHL = minimum_depth(root->left), minHR = minimum_depth(root->right);
    if(!root->left && root->right) return 1+minHR;
    if(root->left && !root->right) return 1+minHL;
    return 1 + min(minHR, minHL);
}
// ===================================================================
// iterative version, BFS
int minDepth(TreeNode *root) {
    if(!root) return 0;
    if(!root->left && !root->right) return 1;
    queue<TreeNode*> q;
    q.push(root);
    int min_depth = 1, level1 = 1, level2 = 0;
    while(!q.empty()) {
        TreeNode *cur = q.front();
        q.pop();
        level1--;
        // if(!cur) continue; // wrong!! cannot write like this. otherwise, POS1 cannot be executed.
        if(cur) {
            if(!cur->left && !cur->right) return min_depth;
            q.push(cur->left);
            q.push(cur->right);
            level2 += 2;
        }
        if(level1 == 0) { // POS1
            level1 = level2;
            min_depth++;
            level2 = 0;
        }
    }
    return min_depth;
}

// ===================================================================
// better iterative version!
int minDepth(TreeNode *root) {
  if(!root) return 0;
  if(!root->left && !root->right) return 1;
  queue<TreeNode*> q;
  q.push(root);
  int min_depth = 1, level1 = 1, level2 = 0;
  while(!q.empty()) {
    TreeNode *cur = q.front();
    q.pop();
    level1--;
    if(!cur->left && !cur->right) return min_depth;
    if(cur->left) { q.push(cur->left); level2++; }
    if(cur->right) { q.push(cur->right); level2++; }
    if(level1 == 0) { // POS1
      level1 = level2;
      min_depth++;
      level2 = 0;
    }
  }
  return min_depth;
}

// ===================================================================
int maximum_depth(TreeNode* root)
{
	if(root == NULL) return 0;
	int lh = maximum_depth(root->left);
	int rh = maximum_depth(root->right);
	return (lh > rh) ? (lh + 1) : (rh + 1);
}