LeetCode hot 100题解
文章目录
1.两数之和
给定一个整数数组 nums
和一个整数目标值 target
,请你在该数组中找出 和为目标值 target
的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
算法1 暴力枚举
暴力枚举方法很简单:两重循环枚举下标 i,j,然后判断 nums[i]+nums[j]
是否等于 target
时间复杂度:由于有两重循环,所以复杂度是 O(n2)
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
for(int i = 0; i < nums.size(); i++)
{
for(int j = i + 1; j < nums.size(); j++)
{
if(nums[i] + nums[j] == target) return {i, j};
}
}
return {};
}
};
算法2 哈希表
使用C++中的哈希表——unordered_map<int, int> hash
进行优化。
循环一遍 nums
数组,在每步循环中我们做两件事:
-
判断
target−nums[i]
是否在哈希表中; -
将
nums[i]
插入哈希表中
解释:由于数据保证有且仅有一组解,假设是 [i, j] (i < j)
,则我们循环到 j 时,nums[i]
一定在哈希表中,且有 nums[i] + nums[j] == target
, 所以我们一定可以找到解。
时间复杂度:由于只扫描一遍,且哈希表的插入和查询操作的复杂度是 O(1),所以总时间复杂度是 O(n).
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> hash;
for(int i = 0; i < nums.size(); i++)
{
int other = target - nums[i];
if(hash.count(other)) return {hash[other], i};
hash[nums[i]] = i;
}
return {};
}
};
2.两数相加
算法 模拟
数字由链表存储,类似高精度加法,从个位开始模拟加法过程,用t存进位。
/**
* 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
//定义一个新列表,pre指向头结点,cur指向当前加数位置
auto pre = new ListNode(-1), cur = pre;
int t = 0;
while(l1 || l2 || t)//t放在while里,最后一位(最高位)有进位时的特判不用放下面
{
if(l1) t += l1->val, l1 = l1->next;
if(l2) t += l2->val, l2 = l2->next;
cur->next = new ListNode(t % 10);
cur = cur->next;
t /= 10;
}
return pre->next;
}
};
3.无重复字符的最长字串
算法 双指针扫描
定义两个指针 i,j(j <= i)
,表示当前扫描到的字串是 [j, i]
闭区间,维护一个“滑动窗口”。过程中用一个哈希表(序列是数字的话数组也行)表示 [j, i]
中每个字符出现的次数。
双指针算法思想,先想暴力做法:遍历i,i在每个位置上时j从左端开始遍历,记录每个i位置的最长字串。然后想双指针优化:j可以不用每次回到开头,一直向右移动(见代码)。
复杂度分析:由于 i,j 均最多增加n次,且哈希表的插入和更新操作的复杂度都是 O(1),因此,总时间复杂度 是O(n).
class Solution {
public:
int lengthOfLongestSubstring(string s) {
unordered_map<char, int> hash;
int res = 0;
for(int i = 0, j = 0; i < s.size(); i++)
{
hash[s[i]]++;
//目前段无重复,新进来的数有重复,一定是新进来的数跟之前数重复
while(hash[s[i]] > 1)
{ //j会一直向右移(不左移)直到无重复
hash[s[j]]--;
j++;
}
res = max(res, i - j + 1);
}
return res;
}
};
4.寻找两个正序数组的中位数
算法 递归
原问题难以直接递归求解,所以我们先考虑这样一个问题:
在两个有序数组中,找出第k小的数。
如果该问题可以解决,那么第 (n + m) / 2
小的数就是我们要求的中位数。
首先我们给出 find 函数的参数含义:表示从 nums1[i : nums1.size() - 1]
和 nums2[j : nums2.size() - 1]
这两个切片中找到第 k 小的数字。假设 nums1
和 nums2
的切片元素个数分别为 len1
和 len2
,为了方便讨论,我们定义为 len1 < len2
。
先从简单情况入手,假设 m, n ≥ k / 2
,我们先从 nums1
和 nums2
中各取前 k / 2
个元素,令 si = i + k / 2, sj = j + k / 2
,得到切片 nums1[i : si - 1]
和 nums2[j : sj - 1]
:
- 如果
nums1[si − 1] <= nums2[sj − 1]
,则说明nums2
中取的元素过多,nums1
中取的元素过少;因此nums1
中的前k / 2
个元素一定都小于等于第k
小的数,所以我们可以先删除(不管)这部分数,将问题递归成在剩下的数中找第k − ⌊k / 2⌋
小的数。 - 如果
nums1[k / 2 − 1 ] > nums2[k / 2 − 1]
,同理可说明nums2
中的前k / 2
个元素一定都小于等于第k
小的数,类似可将问题的规模减少一半。
然后考虑边界情况,如果 m < k / 2
,则我们从 nums1
中取出全部的 m
个元素,从 nums2
中取 k / 2
个元素(由于 k = (n + m) / 2
,因此 m, n
不可能同时小于 k / 2
):
-
如果
nums1[si − 1] ≤ nums2[sj − 1]
,则nums1
中的所有元素一定都小于等于第k
小的数,因此第k
小的数是nums2[sj + k − 1]
。 -
如果
nums1[si − 1] > nums2[sj − 1]
同上,即nums2
中的前k / 2
个元素一定都小于等于第k
小的数,我们可以将问题递归成在剩下的数中找第k − ⌊k / 2⌋
小的数。
时间复杂度分析:k = (m + n) / 2 ,且每次递归 k 的规模都减少一半,因此时间复杂度是 O( log(k) ) = O( log(m+n) ).
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int total = nums1.size() + nums2.size();
if(total % 2) return find(nums1, 0, nums2, 0, total / 2 + 1);
else
{
int left = find(nums1, 0, nums2, 0, total / 2);
int right = find(nums1, 0, nums2, 0, total / 2 + 1);
return (left + right) / 2.0;
}
}
//找第k小的数
int find(vector<int>& nums1, int i, vector<int>& nums2, int j, int k)
{
if(nums1.size() - i > nums2.size() - j) return find(nums2, j, nums1, i, k);//保证nums1是短的那个
if(i == nums1.size()) return nums2[j + k - 1];//nums1遍历完了
if(k == 1) return min(nums1[i], nums2[j]);//k=1且num1未遍历完时,取两数组开头两数中小的那个
int si = min(i + k / 2, (int)nums1.size()), sj = j + k / 2;
if(nums1[si - 1] <= nums2[sj - 1])
return find(nums1, si, nums2, j, k - (si - i));
else
return find(nums1, i, nums2, sj, k - (sj - j));
}
};
5. 最长回文字串
算法 双指针中心扩散(枚举)
时间复杂度分析:一共两重循环,时间复杂度是 O(n2).
class Solution {
public:
string longestPalindrome(string s) {
string res;
//中心扩散法遍历所有奇数和偶数的情况,每个位置从中间往两边匹配
for(int i = 0; i < s.size(); i++)
{
//奇数
int l = i - 1, r = i + 1;
while(l >= 0 && r < s.size() && s[l] == s[r]) l--, r++;
if(res.size() < r - l - 1) res = s.substr(l + 1, r - l - 1);
//偶数
l = i, r = i + 1;
while(l >= 0 && r < s.size() && s[l] == s[r]) l--, r++;
if(res.size() < r - l - 1) res = s.substr(l + 1, r - l - 1);
}
return res;
}
};
6. Z字形变换
算法 找规律
按某种形状打印字符的题目,一般考虑通过画图找规律来做。
对于行数是n的情况:
- 对于第一行和最后一行,是公差为 2(n−1) 的等差数列,首项是 0 和 n−1;
- 对于第 i 行 (0 < i < n − 1),是两个公差为 2(n−1) 的等差数列交替排列(竖着的跟竖着的组成等差数列,斜着的跟斜着的组成等差数列),首项分别是 i 和 2n − 2 − i;
所以我们可以从上到下,依次打印每行的字符。
时间复杂度分析:每个字符遍历一遍,所以时间复杂度是 O(n).
class Solution {
public:
string convert(string s, int numRows) {
string res;
int n = numRows;
if(n == 1) return s;
for(int i = 0; i < n; i ++)
{
if(i == 0 || i == n - 1)//第一行和最后一行
{
for(int j = i; j < s.size(); j += 2 * n - 2)
res += s[j];
}
else//除了第一行和最后一行的中间行
{
for(int j = i, k = 2 * n - 2 - i; j < s.size() || k < s.size(); j += 2 * n - 2, k += 2 * n - 2)
{
if(j < s.size()) res += s[j];
if(k < s.size()) res += s[k];
}
}
}
return res;
}
};
7. 整数反转
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RCvWXiZ4-1666691175359)(https://cdn.jsdelivr.net/gh/RunxunWu/image-store/img/202208252214927.png)]
算法 循环模拟
依次从右往左计算出每位数字,然后逆序累加在一个整数中。需要判断溢出。
在C++中,负数的取模运算和数学意义上的取模运算不同,结果还是负数,所以我们不需要对负数进行额外处理。
class Solution {
public:
int reverse(int x) {
int r = 0;
while(x)
{
if(r > 0 && r > (INT_MAX - x % 10) / 10) return 0;
if(r < 0 && r < (INT_MIN - x % 10) / 10) return 0;
r = r * 10 + x % 10;
x /= 10;
}
return r;
}
};
8. 字符串转换整数(atoi)
算法 模拟
时间复杂度分析:假设字符串长度是 n,每个字符最多遍历一次,所以总时间复杂度是 O(n).
class Solution {
public:
int myAtoi(string s) {
int res = 0;//结果
int i = 0;//下标
while(i < s.size() && s[i] == ' ') i++;
if(i == s.size()) return 0;//特判空字符串情况
int minus = 1;
if(s[i] == '-') minus = -1, i++;
if(s[i] == '+')
{
if(minus == -1) return 0;//陷阱样例"-+12"
else i++;
}
while(i < s.size() && s[i] >= '0' && s[i] <= '9')
{
int x = s[i] - '0';
if(minus > 0 && res > (INT_MAX - x) / 10) return INT_MAX;
if(minus < 0 && -res < (INT_MIN + x) / 10) return INT_MIN;//这里的res一定是正的
if(-res * 10 - x == INT_MIN) return INT_MIN;
res = res * 10 + x;
i++;
}
return res * minus;
}
};
9. 回文数
算法1 转化为字符串利用函数
class Solution {
public:
bool isPalindrome(int x) {
if(x < 0) return false;
string s = to_string(x);
return s == string(s.rbegin(), s.rend());
}
};
算法2 不转成字符串 数学模拟
class Solution {
public:
bool isPalindrome(int x) {
if(x < 0) return false;
int y = x;
long long res = 0;
while(x)
{
res = res * 10 + x % 10;
x /= 10;
}
return y == res;
}
};