一颗完全二叉树，求其结点个数

网上看了很多人的答案，都说最优解是o(n），想到了一种更快的算法，复杂度是O(lgn的平方），就是对左右子树进行二分，找最后一层的最右边那个结点即可：

#include <iostream>
#include <cmath>
#include <stdlib.h>

using namespace std;

struct Node {
  Node* left;
  Node* right;
  ~Node() {
    if (left) {
      delete left;
      left = NULL;
    }
    if (right) {
      delete right;
      right = NULL;
    }
  }
};

int GetDepth(Node* root) {
  int depth = 0;
  while (root) {
    depth++;
    root = root->left;
  }
  return depth;
}

void GetMostRightDepthAndIndex(Node* root, int* depth, int* index) {
  while (root) {
    if (root->right) {
      root = root->right;
      *index = (*index - 1) * 2;
      *index += 2;
      *depth += 1;
    } else if (root->left) {
      root = root->left;
      *index = (*index - 1) * 2;
      *index += 1;
      *depth += 1;
    } else {
      return;
    }
  }
}

void GetMostLeftDepthAndIndex(Node* root, int* depth, int* index) {
  while (root) {
    if (root->left) {
      root = root->left;
      *index = (*index - 1) * 2;
      *index += 1;
      *depth += 1;
    }
    else if (root->left) {
      root = root->right;
      *index = (*index - 1) * 2;
      *index += 2;
      *depth += 1;
    } else {
      return;
    }
  }
}

void GetNodeNum(Node* root, int cur_depth, int cur_index,
    int* node_num, int max_depth) {
  if (!root->left) {
    if (cur_depth - 1 >= 1) {
      *node_num += pow(2, cur_depth - 1) - 1;
    }
    *node_num += cur_index;
    return;
  }
  int ml_depth = root->left ? cur_depth + 1 : cur_depth;
  int ml_index = (cur_index - 1) * 2 + 1;
  int mr_depth = root->right ? cur_depth + 1 : cur_depth;
  int mr_index = (cur_index - 1) * 2 + 2;
  GetMostRightDepthAndIndex(root->left, &ml_depth, &ml_index);
  GetMostLeftDepthAndIndex(root->right, &mr_depth, &mr_index);
  if (ml_depth == mr_depth) {
    if (ml_depth == max_depth) {
      GetNodeNum(root->right, cur_depth + 1, (cur_index - 1) * 2 + 2,
          node_num, max_depth);
    } else if (ml_depth < max_depth) {
      GetNodeNum(root->left, cur_depth + 1, (cur_index - 1) * 2 + 1,
          node_num, max_depth);
    } else {
      std::cout << "illegal tree";
      exit(1);
    }
  } else if (ml_depth > mr_depth) {
    if (ml_depth == max_depth && mr_depth == max_depth - 1) {
      *node_num = pow(2, ml_depth - 1) - 1 + ml_index;
    }
  } else {
    std::cout << "illegal tree";
    exit(1);
  }
}

int main() {
  /* Input: create a  */
  // depth 1
  Node* root = new Node();
  // depth 2
  root->left = new Node();
  root->right = new Node();
  // depth 3
  root->left->left = new Node();
  root->left->right = new Node();
  root->right->left = new Node();
  root->right->right = new Node();
  // depth 4
  root->left->left->left = new Node();
  root->left->left->right= new Node();
  root->left->right->left = new Node();
  root->left->right->right = new Node();
  root->right->left->left = new Node();
  root->right->left->right = new Node();
  root->right->right->left = new Node();
  root->right->right->right = new Node();
  // depth 5
  root->left->left->left->left = new Node();

  int root_depth = 1;
  int root_index = 1;
  int max_depth = GetDepth(root);
  int node_num = 0;
  GetNodeNum(root, root_depth, root_index, &node_num, max_depth);
  std::cout << "node_num = " << node_num << endl;
  delete root;
}