#LeeCode刷题#递归

更多的递归会在后面几部分用到，这里只是简单练习一下思想

树的遍历

98. 验证二叉搜索树

题目链接

• 采用中序遍历的递归方法

/**
 * 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:
    TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if(root == nullptr)
            return true;
        if(!isValidBST(root->left))
            return false;
        if(pre!=nullptr && root->val <= pre->val)
            return false;
        pre = root;
        if(!isValidBST(root->right))
            return false;
        return true;
    }
};

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 height(TreeNode* root){
        if(root == nullptr)
            return 0;
        else
            return max(height(root->left), height(root->right)) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == nullptr)
            return true;
        else
            return abs(height(root->left) - height(root->right))<=1 && isBalanced(root->left) && isBalanced(root->right);
    }
};

124. 二叉树中的最大路径和

题目链接

• 这道题思路相对不难，就是遍历左边的价值和右边的价值，最后一个节点可以同时拥有左右节点的价值，而其他节点，由于每个只能经过一次，因此只能选择左右节点中最大的，以自己相加
• 需要注意的是，如果左右节点中有负值，就不必加上了

/**
 * 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 maxSum = INT_MIN;
    int maxGain(TreeNode* root){
        if(root == nullptr)
            return 0;
        int leftGain = max(0,maxGain(root->left));
        int rightGain = max(0,maxGain(root->right));
        int newGain = root->val + leftGain + rightGain;
        maxSum = max(maxSum, newGain);
        return root->val + max(leftGain, rightGain);

    }
    int maxPathSum(TreeNode* root) {
        maxGain(root);
        return maxSum;
    }
};

其他

2. 两数相加

题目链接

• 这里好像不用递归，直接while循环更好理解也更常用一些QWQ

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void fun(ListNode* l1, ListNode* l2, ListNode* result, int add){
        int sum;
        if(l1 != nullptr || l2 != nullptr){
            if(l1 == nullptr){
                sum = l2->val + add;
                if(sum >= 10) add = 1;
                else add = 0;
                sum %= 10;
                result->next = new ListNode(sum);
                result = result->next;
                fun(l1, l2->next, result, add);
            }else if(l2 == nullptr){
                sum = l1->val + add;
                if(sum >= 10) add = 1;
                else add = 0;
                sum %= 10;
                result->next = new ListNode(sum);
                result = result->next;
                fun(l1->next, l2, result, add);
            }else{
                sum = l1->val + l2->val + add;
                if(sum >= 10) add = 1;
                else add = 0;
                sum %= 10;
                result->next = new ListNode(sum);
                result = result->next;
                fun(l1->next, l2->next, result, add);
            }

        }else{
            if(add)
                result-> next = new ListNode(add);
        }
    }

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* result = new ListNode(0);
        fun(l1, l2, result, 0);
        return result->next;
    }
};

21. 合并两个有序链表

题目链接

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void fun(ListNode* l1, ListNode* l2, ListNode* result){
        if(l1 != nullptr || l2 != nullptr){
            if(l1 == nullptr){
                result->next = new ListNode(l2->val);
                result = result->next;
                fun(l1, l2->next, result);
            } else if(l2 == nullptr){
                result->next = new ListNode(l1->val);
                result = result->next;
                fun(l1->next, l2, result); 
            } else{
                if(l1->val < l2->val){
                    result->next = new ListNode(l1->val);
                    result = result->next;
                    fun(l1->next, l2, result);
                }else{
                    result->next = new ListNode(l2->val);
                    result = result->next;
                    fun(l1, l2->next, result);
                }
            }
        }
    }

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* result = new ListNode(0);
        fun(l1, l2, result);
        return result->next;       
    }
};

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

题目链接

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==nullptr || head->next==nullptr){
            return head;
        }
        ListNode* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};