完全二叉树的结点个数

递归法

1、确定递归函数的参数和返回值：参数就是传⼊树的根节点,返回就返回以该节点为根节点⼆叉树的节点数量，所以返回值为int类型。

int countNodes(TreeNoed* root)

2、确定终⽌条件：如果为空节点的话，就返回0，表示节点数为0。代码如下：

if(node==nullptr) return 0;

3、确定单层递归的逻辑：先求它的左⼦树的节点数量，再求的右⼦树的节点数量，最后取总和再加⼀（加1是因为算上当前中间节点）就是⽬前节点为根节点的节点数量。

 int leftnodes=getnodes(node->left); //左
 int rightnodes=getnodes(node->right);//右
 int sum=leftnodes+rightnodes;//中
 return sum+1;

完整递归代码：

class Solution {
public:
    int getnodes(TreeNode* node)
    {
      if(node==nullptr) return 0;
      int leftnodes=getnodes(node->left); //左
      int rightnodes=getnodes(node->right);//右
      int sum=leftnodes+rightnodes;//中
      return sum+1;
    }
    
    int countNodes(TreeNode* root) {
        return getnodes(root);
    }
};

时间复杂度：O(n)
空间复杂度：O(logn)，算上了递归系统栈占⽤的空间

迭代法

class Solution{
public:
    int countNodes(TreeNode* root){
       if(root==nullptr) return 0;
       queue<TreeNode*> que;
       que.push(root);
       int sum=0;
       
       while(!que.empty()){
         int size=que.size();
         for(int ii=0;ii<size;ii++){
           sum++;
           TreeNode* node=que.front();
           que.pop();
           if(node->left) que.push(node->left);
           if(node->right) que.push(node->right);
         }
       }
       return sum;
    }
};

时间复杂度：O(n)空间复杂度：O(n)

利用完全二叉树的性质

完全二叉树只有两种情况：
1、满二叉树—–>高度为h的满二叉树有 2^h-1 个结点。
2、最后⼀层叶⼦节点没有满。—->也就是说如果整个树不是满二叉树就分别递归其左右孩子，递归到一定深度一定会有左孩子或右孩子为满二叉树，然后可以按照满二叉树来计算节点个数。

class Solution{
public:
    int countNodes(TreeNode* root){
        if(root==nullptr) return 0;
        
        TreeNode* left=root->left;
        TreeNode* right=root->right;
        
        int leftHeight=0,rightHight=0;
        while(left){ //求左子树的高度
          left=left->left; leftHeight++;
        }
        while(right){ //求右子树的高度
          right=right->right; rightHeight++;
        }
        
        if(leftHeight==rightHeight){
          return (2<<leftHeight)-1; //2<<相当于2^2 ,所以高度初始化为0 
        }

        //如果整棵树不是满二叉树，就递归其左右孩子
        return countNodes(root->left)+countNodes(root->right)+1；
    }
};

时间复杂度：O(logn * logn)
空间复杂度：O(logn)