LeetCode高频算法刷题记录2

Frankenstein@

已于 2023-05-17 00:09:10 修改

阅读量278

点赞数

分类专栏：刷题笔记文章标签： leetcode 算法 c++ 数据结构面试

于 2023-05-16 23:54:39 首次发布

本文链接：https://blog.csdn.net/qq_43631268/article/details/130695123

版权

刷题笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1. 最大子数组和【简单】

题目链接：https://leetcode.cn/problems/maximum-subarray/
参考题解：https://leetcode.cn/problems/maximum-subarray/solution/zui-da-zi-xu-he-by-leetcode-solution/

1.1 题目描述

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例2：

输入：nums = [1]
输出：1

示例3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

1.2 解题思路

动态规划，对于数组中的第i个元素，以其结尾的具有最大和的连续子数组一定是下面这两种情况之一：以第i-1个元素结尾的具有最大和的连续子数组加上第i个元素；第i个元素本身。为什么会有后一种情况呢？因为前一种情况可能会是负数，比如[-7,-1]这种情况，第1个元素其本身就要比第0个元素-7要大。

1.3 代码实现

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0;
        int ans = nums[0];
        for (int i = 0; i < nums.size(); ++i) {
            pre = max(pre + nums[i], nums[i]);
            ans = max(pre, ans);
        }
        return ans;
    }
};

2. 合并两个有序链表【简单】

题目链接：https://leetcode.cn/problems/merge-two-sorted-lists/
参考题解：https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/

2.1 题目描述

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例1：
在这里插入图片描述

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例2：

输入：l1 = [], l2 = []
输出：[]

示例3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

2.2 解题思路

递归实现起来比较简单。如果l1值更小，那么可以递归地合并l1->next和l2。边界情况是某一个链表空了，直接把另一个链表接到结果后面就行了。

2.3 代码实现

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if (list1 == nullptr) {
            return list2;
        }
        else if (list2 == nullptr) {
            return list1;
        }
        else if (list1 -> val < list2 -> val) {
            list1 -> next = mergeTwoLists(list1 -> next, list2);
            return list1;
        }
        else {
            list2 -> next = mergeTwoLists(list1, list2 -> next);
            return list2;
        }
    }
};

3. 两数之和【简单】

题目链接：https://leetcode.cn/problems/two-sum/
参考题解：https://leetcode.cn/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/

3.1 题目描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

3.2 解题思路

一个巧妙的思路是用哈希表把已经访问过的元素存下来，在访问下一个元素i时，查看目标值与当前元素i的差是不是在之前遍历过了，如果哈希表中有这样的元素j，那么 {i, j} 就是答案。

3.3 代码实现

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash;
        for(int i = 0; i < nums.size(); ++i) {
            if (hash.count(target - nums[i])) {
                return {i, hash[target - nums[i]]};
            }
            hash[nums[i]] = i;
        }
        return {-1, -1};
    }
};

4. 二叉树的层序遍历【中等】

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/
参考题解：https://leetcode.cn/problems/binary-tree-level-order-traversal/solution/er-cha-shu-de-ceng-xu-bian-li-by-leetcode-solution/

4.1 题目描述

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例2：

输入：root = [1]
输出：[[1]]

示例3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

4.2 解题思路

层序遍历是用队列来实现。每次把队首的节点弹出来，再把其左右节点加到队尾。每次往队尾加节点之前，队列中已有的所有节点，事实上就是位于树同一层的节点，所以每次把队列中所有已存节点出队，得到的就是一层的所有节点。可以在每次出队前记录下当前队列的长度，用一次循环实现，这样也就不会影响左右节点入队了。

4.3 代码实现

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ans;
        if (root == nullptr) {
            return ans;
        }
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()) {
            int len = q.size();
            ans.push_back(vector <int> ());
            for(int i = 0; i < len; ++i) {
                ans.back().push_back(q.front() -> val);
                if (q.front() -> left != nullptr) {
                    q.push(q.front() -> left);
                }
                if (q.front() -> right != nullptr) {
                    q.push(q.front() -> right);
                }
                q.pop();
            }
        }
        return ans;
    }
};

5. 最长回文子串【中等】

题目链接：https://leetcode.cn/problems/longest-palindromic-substring/
参考题解：https://leetcode.cn/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/

5.1 题目描述

给你一个字符串 s，找到 s 中最长的回文子串。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

示例2：

输入：s = “cbbd”
输出：“bb”

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母组成

5.2 解题思路

对于字符串中的每个字符，可以考虑往两边不断尝试扩展，查看其左右字符是否相同。但是要注意可能会有连续两个字符相同的情况，也算回文，所以在调用扩展函数时要分别考虑i, i字符和i, i+1字符的扩展。

5.3 代码实现

class Solution {
public:
    pair<int, int> expand(string s, int i, int j) {
        while (i >= 0 && j < s.length() && (s[i] == s[j])) {
            --i;
            ++j;
        }
        return {i + 1, j - 1};
    }
    string longestPalindrome(string s) {
        int start = 0;
        int end = 0;
        for (int i = 0; i < s.length(); ++i) {
            auto [left1, right1] = expand(s, i, i);
            auto [left2, right2] = expand(s, i, i + 1);
            if (right1 - left1 > end - start) {
                start = left1;
                end = right1;
            }
            if (right2 - left2 > end - start) {
                start = left2;
                end = right2;
            }
        }
        return s.substr(start, end - start + 1);
    }
};