本文已参与「新人创作礼」活动，一起开启掘金创作之路。
两数之和
给定一个整数数组
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 <= 104-109 <= nums[i] <= 109-109 <= target <= 109- 只会存在一个有效答案
进阶： 你可以想出一个时间复杂度小于
O(n2)的算法吗？
法一：暴力解题
思路：最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。
学到了一种表达方法 ，return返回两个值
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int n=nums.size();
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
if(nums[i]+nums[j]==target)
{
return {i,j};//返回两个值
}
}
}
return {};
}
};
复杂度分析：
时间复杂度: O(N2), 其中N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
空间复杂度: O(1)。
法二：哈希表
方法一的时间复杂度较高的原因 是寻找 target - x 的时间复杂度过高。
因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int n=nums.size();
unordered_map<int,int>hashtable;
for(int i=0;i<n;i++)
{
auto it=hashtable.find(target-nums[i]);///auto根据变量值推断变量类型，
//it是iterator迭代器，访问、读写容器中的元素，需要使用迭代器iterator。
if(it!=hashtable.end())//若键key与其值的键值对在容器中存在，
//则返回一个指向该键值对的正向迭代器，反之则返回一个指向容器中最后一个键值对之后位置的迭代器。
{
return {it->second,i};
}
hashtable[nums[i]]=i;///第一键值是值 第二键值是下标
}
return {};
}
};
复杂度分析
时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找target - x。
空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
合并两个有序数组
给你两个按 非递减顺序 排列的整数数组
nums1**和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你 合并
nums2**到nums1中，使合并后的数组同样按 非递减顺序 排列。注意： 最终，合并后数组不应由函数返回，而是存储在数组
nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。示例 1：
输入： nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 输出： [1,2,2,3,5,6] 解释： 需要合并 [1,2,3] 和 [2,5,6] 。 合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。示例 2：
输入： nums1 = [1], m = 1, nums2 = [], n = 0 输出： [1] 解释： 需要合并 [1] 和 [] 。 合并结果是 [1] 。示例 3：
输入： nums1 = [0], m = 0, nums2 = [1], n = 1 输出： [1] 解释： 需要合并的数组是 [] 和 [1] 。 合并结果是 [1] 。 注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。提示：
nums1.length == m + nnums2.length == n0 <= m, n <= 2001 <= m + n <= 200-109 <= nums1[i], nums2[j] <= 109进阶： 你可以设计实现一个时间复杂度为
O(m + n)的算法解决此问题吗？
法一：直接合并后排序
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
for(int i=0;i<n;i++)
{
nums1[m++]=nums2[i];
}
sort(nums1.begin(),nums1.end());
}
};
复杂度分析：
时间复杂度：O((m+n)log(m+n))。排序序列长度为 m+n，套用快速排序的时间复杂度即可，平均情况为 O((m+n)log(m+n))。
空间复杂度：O(log(m+n))。排序序列长度为 m+n，套用快速排序的空间复杂度即可，平均情况为O(log(m+n))。
法二：双指针
开辟一个临时数组sort[ ]，和两个临时指针，指向两个数组的头元素，一次比较进入sort[ ]
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int p1=0,p2=0;
int sort[m+n];
int temp=0;
while(p1<m||p2<n) {
if(p1==m)
temp=nums2[p2++];
else if(p2==n)
temp=nums1[p1++];
else if(nums1[p1]<nums2[p2])
temp=nums1[p1++];
else temp=nums2[p2++];
sort[p1+p2-1]=temp;
}
for(int i=0; i<m+n; i++)
nums1[i]=sort[i];
}
};
复杂度分析
时间复杂度：O(m+n)。指针移动单调递增，最多移动m+n 次，因此时间复杂度为O(m+n)。
空间复杂度：O(m+n)。需要建立长度为 m+n 的中间数组sort。
法三：逆向指针
直接对nums1[ ]数组进行修改，开辟两个指针，分别指向两个数组的尾元素p1,p2，从后向前遍历，比较大者插入nums1[ ]数组（用尾指针tail来记录存储）
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int p1=m-1,p2=n-1;
int tail=m+n-1;
int temp=0;
while(p1>=0||p2>=0)
{
if(p1==-1)
temp=nums2[p2--];
else if(p2==-1)
temp=nums1[p1--];
else if(nums1[p1]<nums2[p2])
temp=nums2[p2--];
else temp=nums1[p1--];
nums1[tail--]=temp;
}
}
};
复杂度分析
时间复杂度：O(m+n)。指针移动单调递减，最多移动 m+n 次，因此时间复杂度为O(m+n)。
空间复杂度：O(1)。直接对数组 nums 1 原地修改，不需要额外空间。
