DAY15||222.完全二叉树的节点个数|110.平衡二叉树|257.二叉树的所有路径|404.左叶子之和（只有递归场）-优快云博客

222.完全二叉树的节点个数

完全二叉树定义：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

如果一棵树不是满二叉树，就递归左右子树直到找到满二叉树为止，再用公式计算节点个数。

而判断是否是满二叉树，就递归遍历看左右子树的深度是否相等。是就说明是满二叉树。

本题思路后序遍历，找到满二叉树时就回溯（类似说法？）时，加上当前节点，直到回到根节点，得知总节点数。

代码

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root==NULL)return 0;
        TreeNode*left=root->left;
        TreeNode*right=root->right;
        int leftdepth=0,rightdepth=0;
        
        while(left)
        {
            left=left->left;
            leftdepth++;
        }
         while(right)
        {
            right=right->right;
            rightdepth++;
        }
        if(leftdepth==rightdepth)return (2<<leftdepth)-1;

        int leftTreeNum=countNodes(root->left);
        int rightTreeNum=countNodes(root->right);
        int result=leftTreeNum+rightTreeNum+1;
        return result;


    }
};

110.平衡二叉树

题目：110. 平衡二叉树 - 力扣（LeetCode）

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

但leetcode中强调的深度和高度很明显是按照节点来计算的，如图：

求深度从上往下查（前序遍历）。

求高度从下往上查（后序遍历）。

在递归逻辑里，如果左右子树差大于1就返回-1，否则就返回最大高度。

class Solution {
public:
    int getHeight(TreeNode*node)
    {
        if(node==NULL)return 0;
        int leftheight=getHeight(node->left);
        if(leftheight==-1)return -1;
        int rightheight=getHeight(node->right);
        if(rightheight==-1)return -1;
        
        return abs(leftheight-rightheight)>1?-1:1+max(leftheight,rightheight);//判断左右子树是否平衡，平衡则返回该节点的高度

    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root)==-1?false:true;

    }
};

法二，迭代，栈模拟，后序遍历。

257.二叉树的所有路径

题目：257. 二叉树的所有路径 - 力扣（LeetCode）

本题要求从根节点到叶节点的路径，因此用前序遍历。

前序遍历及回溯过程如下图

递归写法

1.确定函数参数与返回值。

要传入根节点，存放路径的vector函数，以及存放所有路径的结果集函数。递归不需要返回值

2.终止条件

左右孩子为空时。

这里使用vector 结构path来记录路径，所以要把vector 结构的path转为string格式，再把这个string 放进 result里。

那么为什么使用了vector 结构来记录路径呢？ 因为在下面处理单层递归逻辑的时候，要做回溯，使用vector方便来做回溯。

3.单层递归逻辑

回溯和递归一起发生。存入节点进path时，也要回溯删除节点存入第二条路径。最后存入结果集。

代码

class Solution {
private:
    void traversal(TreeNode*cur,vector<int>&path,vector<string>&result)
    {
        path.push_back(cur->val);//中
        //当遇到叶子节点时，就记录路径保存结果
        if(cur->left==NULL&&cur->right==NULL)
        {
            string spath;
            for(int i=0;i<path.size()-1;i++)
            {
                spath+=to_string(path[i]);
                spath+="->";
            }
            spath+=to_string(path[path.size()-1]);
            result.push_back(spath);//存入结果集
            return;
        }
        
        if(cur->left)//左
        {
            traversal(cur->left,path,result);//递归到左子树
            path.pop_back();//回溯
            
        }

        if(cur->right)//右
        {
            traversal(cur->right,path,result);
            path.pop_back();
        }

    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int>path;
        vector<string>result;
        if(root==NULL)return result;
        traversal(root,path,result);
        return result;
    }
};

迭代法中何时用栈何时用队列呢？

如果是模拟前中后序遍历就用栈，如果是适合层序遍历就用队列，当然还是其他情况，那么就是先用队列试试行不行，不行就用栈。

404.左子叶之和

题目：404. 左叶子之和 - 力扣（LeetCode）

叶子节点定义，左孩子不为空，且左孩子的左右孩子都为空。（且要通过父亲来判断是不是左叶子）

思路：后序遍历。

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==NULL)return 0;
        if(root->left==NULL&&root->right==NULL)return 0;

        int leftvalue=sumOfLeftLeaves(root->left);//左
        if(root->left!=NULL&&root->left->left==NULL&&root->left->right==NULL)
        leftvalue+=root->left->val;

        int rightvalue=sumOfLeftLeaves(root->right);//右

        return leftvalue+rightvalue;

    }
};