刷四道题，利用模版搞懂递归

Leetcode 24 两两交换链表中的节点

 ListNode* swapPairs(ListNode* head) {
        //1、递归出口
        if(head==NULL||head->next==NULL){
            return head;
        }
        //2、考虑向上一级的返回值，当然是排序好的链表

        //3、本级递归应该做什么，应该求两两交换链表
        //当前问题在本级递归分解为：
        //已知条件：head head->next 已经排序好的链表
        //做法：将head->next和head交换，再接到已经排序好的链表即可
        
        ListNode *p=head;
        ListNode *q=head->next;
        ListNode *r=swapPairs(head->next->next);
        p->next=r;
        q->next=p;
        return q;
    }

Leetcode 104 二叉树的最大深度

 int maxDepth(TreeNode* root) {
        //1、递归出口
        if(root==NULL){
            return 0;
        }
        //2、考虑向上一级返回值：当然是返回最大深度

        //3、本级递归应该做什么：应该做的是求最大深度
        //当前问题在本级递归分解为：
        //已知条件：已经求好的左子树最大深度 已经求好的右子树最大深度 当前节点
        //做法：取已经求好的左子树最大深度 已经求好的右子树最大深度最大值，加上当前节点1，返回
        int left_maxDepth=maxDepth(root->left);
        int right_maxDepth=maxDepth(root->right);
        return max(left_maxDepth,right_maxDepth)+1;

    }

Leetcode 110 平衡二叉树

/**
 * 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 helper(TreeNode *root){
        //1、递归出口
        if(root==NULL){
            return 0;
        }
        //2、返回给上一级的返回值:二叉树的高度

        //3、本级递归应该做什么：求出二叉树的高度
        //本级递归分解为：
        //已知条件：左子树高度 右子树高度 
        //做法：选择高度最大子树+1
        return max(helper(root->left),helper(root->right))+1;
    }
    bool isBalanced(TreeNode* root) {
        //1、递归出口
        if(root==NULL){
            return true;
        }
        if(root->left==NULL&&root->right==NULL){
            return true;
        }
        //2、返回给上一级的返回值：是否为平衡二叉树，左右子树差值是否小于等于1

        //3、本级递归应该做什么：求是否为平衡二叉树
        //当前问题在本级递归分解为:
        //已知条件：左子树的高度 右子树的高度 左子树是否为平衡二车数 右子树是否为平衡二叉树
        //做法：求左子树高度和右子树高度的差值，判断是否小于等于1, 左子树满足平衡二叉树 右子树满足平衡二叉树，全满足则改树为平衡二叉树
        int left_height=helper(root->left);
        int right_height=helper(root->right);
        if(abs(left_height-right_height)<=1&&isBalanced(root->left)&&isBalanced(root->right)){
            return true;
        }else{
            return false;
        }
    }
};

Leetcode 101 对称二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
bool helper(TreeNode *l,TreeNode *r){
    //1、递归出口
    if(l==NULL&&r==NULL){
        return true;
    }
    if(l==NULL||r==NULL){
        return false;
    }
    if(l->val!=r->val){
        return false;
    }
    //2、向上级返回值：返回这两个子树是否对称

    //3、本级递归应该做什么：判断两个子树是否对称
    //当前问题分解为：
    //左子树的左子和右子树的右子是否对称   左子树的右子和右子树的左子是否对称
    //做法：如果左子树的左子和右子树的右子是否对称和左子树的右子和右子树的左子是否对称同时满足
    //则两个子树对称
    bool result1=helper(l->left,r->right);
    bool result2=helper(l->right,r->left);
    if(result1&&result2){
        return true;
    }else{
        return false;
    }
}
bool isSymmetric(TreeNode* root) {
    //1、递归出口
    if(root==NULL){
        return true;
    }
    if(root->left==NULL&&root->right==NULL){
        return true;
    }
    //2、向上一级的返回值：是否为对称二叉树，即左子树和右子树是否对称

    //3、本级递归该做什么：求是否为对称二叉树
    //当前问题在本级递归分解为：
    //左子树根节点  右子树根节点  左子树和右子树是否对称
    return helper(root->left,root->right);
}
};