递归二叉树

leetcode二叉树递归运用
自上而下 递归寻找二叉树的最大深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int ans = 0;
    void find_maxDepth(TreeNode*root,int depth){
        if(!root) return;

        if(root->left == nullptr && root->right == nullptr)
            ans = max(ans,depth);
        find_maxDepth(root->left ,depth + 1);
        find_maxDepth(root->right,depth + 1);
    }
    int maxDepth(TreeNode* root) {
        find_maxDepth(root,1);

        return ans;
    }
};

判断二叉树是否对称 傻瓜式写法 【放心食用】

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {

        if(root == nullptr) return true;    // 空树本身就是对称

        queue<TreeNode *> que_left,que_right;   // 定义左右子树队列
        
        que_left.push(root->left),que_right.push(root->right);  // 插入左子树队列  插入右子树队列

        while(!que_left.empty() && !que_right.empty()){ 

            int size_left = que_left.size(), size_right = que_right.size(); // 接收当前左右子树得大小

            if(size_left != size_right) return false;   // 大小不相等 不对称

            for(int i = 0,j = 0;i < size_left,j <size_right;i++,j++){ // 遍历比较左右子树对称节点是否相等

                TreeNode *le = que_left.front(), *ri = que_right.front();
                
                que_left.pop(),que_right.pop();                        // 完成比较弹出

                if (le == nullptr && ri == nullptr) continue;           // 对称节点均为空依然对称
                if (le == nullptr || ri == nullptr || le->val != ri->val) return false; // 一方为空，或者数值不等为假


                que_left.push(le->left);
                que_left.push(le->right);   // 注意左右子树得进队顺序刚好相反  成对称结构
                
                que_right.push(ri->right);
                que_right.push(ri->left); 
            }
        }
       return que_left.empty() && que_right.empty();    // 最后左右队列均为空则为对称结构
    }
};

递归解决二叉树路径和
思路是别人的（呜呜）：
递归法，没递归到一个节点，就拿target-当前节点值，如果存在路径总和等于target，那么最后一个叶子节点一定等于target剩下的值。
如果递归到叶子节点后，剩余的target值不等于叶子节点，说明不存在路径总和等于target。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        if(root->left == nullptr && root->right == nullptr)
            return targetSum == root->val;
        return hasPathSum(root->left,targetSum-root->val) || hasPathSum(root->right,targetSum-root->val);
    }
};