c++解法
文章目录
1、两数之和 （简单）
题目
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
方法一：两遍哈希表
第一次迭代：将每个元素的值和它的索引添加到表中。
第二次迭代：检查每个元素对应的目标元素（target-nums[i]）是否存在于表中。
时间复杂度：遍历两次包含n个元素的列表，哈希表的查找时间是O(1)，所以时间复杂度是O(n)。
空间复杂度：所需的额外空间取决于哈希表中存储的元素数量，该表中存储了n个元素，所以空间复杂度是O(n)。
class Solution{
public:
vector<int> twoSum(vector<int>& nums, int target){
map<int,int> hash;
for(int i=0;i<nums.size();i++)
hash[nums[i]]=i;
for(int i=0;i<nums.size();i++){
int t=target-nums[i];
//用find函数来定位数据出现位置，它返回的是一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器
if(hash.find(t)!=hash.end()&&hash[t]!=i)//不能重复利用这个数组中同样的元素
return vector<int>{i,hash.find(t)->second};//first访问map的第一个元素key，second访问第二个元素value
}
return vector<int>();
}
};
方法二：一遍哈希表
在第一遍遍历元素插入到表中之前，先检查表中是否已经存在当前元素对应的目标元素，如果已经存在，即找到了对应解，将其返回，如果不存在，将当前元素插入到表中继续对下一个元素进行操作。
时间复杂度：遍历包含n个元素的列表一次，哈希表每次查找花费O(1)的时间，因此时间复杂度是O(n)。
空间复杂度：所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储n个元素，所以空间复杂度是O(n)。
class Solution{
public:
vector<int> twoSum(vector<int>& nums, int target){
map<int,int> hash;
for(int i=0;i<nums.size();i++){
int t= target-nums[i];
if(hash.find(t)!=hash.end())
return vector<int>{hash.find(t)->second,i}; //当前元素与之前插入表中的元素进行比对，所以哈希表中元素的索引在前，当前元素序号在后
hash[nums[i]]=i;
}
return vector<int> {};
}
};
2、整数反转（中等）
题目
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
解题方法
这里的result用来存放反转后的结果，使用long类型。（如果使用int，当x过大时，反转后result会出现溢出，例如x=1534236469，
反转后result应为9646324351，但Integer.MAX_VALUE=2147483647,导致溢出，最终result=1056389759，这不是我们想要的结果，
所以这里使用long，判断溢出时，返回result=0）
public int reverse(int x) {
int res;
int a[100];
int i=0;
while(x!=0){
a[i]=x%10;
x=x/10;
i++;
}
int k=1;
for(int j=i-1;j>=0;j--){
res+=a[j]*k; //逆序（1*1+2*10+3*100）
if(res>INT_MAX ||res<INT_MIN)
return 0;
k=k*10;
}
return res;
}
3、无重复字符的最长子串（中等）
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
解题方法
方法一：滑动窗口
思路和算法
我们先用一个例子来想一想如何在较优的时间复杂度内通过本题。
我们不妨以示例一中的字符串 \texttt{abcabcbb}abcabcbb 为例，找出 从每一个字符开始的，不包含重复字符的最长子串，那么其中最长的那个字符串即为答案。对于示例一中的字符串，我们列举出这些结果，其中括号中表示选中的字符以及最长的字符串：
以 (a)bcabcbb 开始的最长字符串为 (abc)abcbb；
以 a(b)cabcbb 开始的最长字符串为 a(bca)bcbb；
以 ab©abcbb 开始的最长字符串为 ab(cab)cbb；
以abc(a)bcbb 开始的最长字符串为abc(abc)bb；
以abca(b)cbb 开始的最长字符串为 abca(bc)bb；
以 abcab©bb 开始的最长字符串为 abcab(cb)b；
以 abcabc(b)b 开始的最长字符串为 abcabc(b)b；
以 abcabcb(b) 开始的最长字符串为 abcabcb(b)。
发现了什么？如果我们依次递增地枚举子串的起始位置，那么子串的结束位置也是递增的！这里的原因在于，假设我们选择字符串中的第 k 个字符作为起始位置，并且得到了不包含重复字符的最长子串的结束位置为 r_k 。那么当我们选择第 k+1个字符作为起始位置时，首先从k+1 到 r_k的字符显然是不重复的，并且由于少了原本的第 k 个字符，我们可以尝试继续增大 r_k，直到右侧出现了重复字符为止。
这样以来，我们就可以使用「滑动窗口」来解决这个问题了：
我们使用两个指针表示字符串中的某个子串（的左右边界）。其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为上文中的 r_k；
在每一步的操作中，我们会将左指针向右移动一格，表示 我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。在移动结束后，这个子串就对应着 以左指针开始的，不包含重复字符的最长子串。我们记录下这个子串的长度；
在枚举结束后，我们找到的最长的子串的长度即为答案。
判断重复字符
在上面的流程中，我们还需要使用一种数据结构来判断 是否有重复的字符，常用的数据结构为哈希集合（即 C++ 中的 std::unordered_set，或include的set，Java 中的 HashSet，Python 中的 set, JavaScript 中的 Set）。在左指针向右移动的时候，我们从哈希集合中移除一个字符，在右指针向右移动的时候，我们往哈希集合中添加一个字符。
c++ set 用法详解
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 哈希集合，记录每个字符是否出现过
set<char> occ;
int n = s.size();
// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
int rk = -1, ans = 0;
// 枚举左指针的位置，初始值隐性地表示为 -1
for (int i = 0; i < n; ++i) {
if (i != 0) {
// 左指针向右移动一格，移除一个字符
occ.erase(s[i - 1]);
}
while (rk + 1 < n && !occ.count(s[rk + 1])) {
// 不断地移动右指针
occ.insert(s[rk + 1]);
++rk;
}
// 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = max(ans, rk - i + 1);
}
return ans;
}
};
复杂度分析
时间复杂度：O(N)，其中 N 是字符串的长度。左指针和右指针分别会遍历整个字符串一次。
空间复杂度：O(∣Σ∣)，其中 Σ 表示字符集（即字符串中可以出现的字符），∣Σ∣ 表示字符集的大小。在本题中没有明确说明字符集，因此可以默认为所有 ASCII 码在 [0, 128)[0,128) 内的字符，即 ∣Σ∣=128。我们需要用到哈希集合来存储出现过的字符，而字符最多有 ∣Σ∣ 个，因此空间复杂度为 O(∣Σ∣)。
4、寻找两个正序数组的中位数（难）
给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。
请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5
解题方法
思路（归并思想）：
- 计算len=nums1.size()+nums2.size()
- 计算中位数位置mid = ( len % 2 == 0 ) ? ( len / 2 - 1 ) : ( len / 2 )
- 标记nums1和nums2当前位置i、j
- 以归并排序算法推进i和j，记录推进次数k
- 当k==mid说明推进到中位数位置
- 判断len是奇偶性，如果是奇数，中位数就是nums1[i] < nums2[j] ? nums[i] : nums[j] ；如果是偶数，则中位数是nums[i]、nums[i+1]、nums[j]、nums[j+1]中较小的两个数的和的一半。
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
double midnum=0;
int n1=nums1.size(),n2=nums2.size();
int len=n1+n2;
if(n1==0 || n2==0){
vector<int> nk=n1==0?nums2:nums1;
if(nk.size()%2==0){midnum=(nk[nk.size()/2]+nk[nk.size()/2-1])/2.0;}
else{midnum=nk[nk.size()/2];}
}else{
int i=0,j=0,k=0,mid=(len%2==0)?(len/2-1):(len/2);
while(i<n1 && j<n2){
if(k==mid){
if(len%2==0){
if(nums1[i]<nums2[j]){
midnum=(nums1[i]+(i+1>=n1?nums2[j]:(nums1[i+1]<nums2[j]?nums1[i+1]:nums2[j])))/2.0;
}else{
midnum=(nums1[j]+(j+1>=n2?nums1[i]:(nums2[j+1]<nums1[i]?nums2[j+1]:nums1[i])))/2.0;
}
}
else{midnum=nums1[i]<nums2[j]?nums1[i]:nums2[j];}
break;
}
if(nums1[i]<nums2[j]){i++;}
else{j++;}
k++;
}
if(i<n1 && j>=n2){
while(i<n1){
if(k==mid){
if(len%2==0){midnum=(nums1[i]+nums1[i+1])/2.0;}
else{midnum=nums1[i];}
break;
}
i++;k++;
}
}
if(j<n2 && i>=n1){
while(j<n2){
if(k==mid){
if(len%2==0){midnum=(nums2[j+1]+nums2[j])/2.0;}
else{midnum=nums2[j];}
break;
}
j++;k++;
}
}
}
return midnum;
}
};
4729
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
