纠结了很久,决定从第一篇写起,每一篇都认真写,多种思路。
给定一个整数数组 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]
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
这道题作为力扣的第一题,标准的简单题目。乍一看,直接双指针穷举就可以了。
算法动画:
废话少说,开撸:
public int[] TwoSum(int[] nums, int target)
{
var length = nums.Length;
for(var i=0; i<length-1; i++)
{
for(var j=i+1; j<length; j++)
{
if(nums[i] + nums[j] == target)
{
return new int[] {i, j };
}
}
}
return null;
}
轻松加愉快,5分钟解决
不过,本着严谨的态度,毕竟是双循环是吧,所以总得测一下大数据量的情况呀,看看10000个数,按照最差情况,最后两个数的和。即,1-10000,和19999:本地88ms。平台上176ms。
然后,其实仔细想想,这个算法就是一个标准的双指针算法,算法复杂度就是O()。其实有更快的算法,就是双指针两端逼近法。
算法图形演示:
TODO: 缺个演示图,稍后补上。一个算法写5分钟,一个图画一个小时 :(
好不好,实力说话。看代码,看同样10000个数的跑的性能:
public int[] TwoSum(int[] nums, int target)
{
var numsInOrder = nums.OrderBy(a => a).ToArray();
var length = nums.Length;
var p1 = 0;
var p2 = length - 1;
while (p1 < p2)
{
var sum = numsInOrder[p1] + numsInOrder[p2];
if (sum > target)
{
p2--;
}
else if(sum<target)
{
p1++;
}
else
{
return new int[] {p1, p2 };
}
}
return null;
}
先跑本地的UT,10ms,性能大大提升!再跑LeetCode:很生气地发现效果不明显,可能是LeetCode的容器的问题。
直接提交!发现错了,才发现。。。。。排序后的原先的顺序没了,程序要输出的是原始的index。好吧,继续,随手加上冒泡,同时用一个新列表存储排序后的索引。(只贴关键代码)
/// <summary>
/// 尝试了先冒泡排序,后双指针逼近法,发现排序太耗时了
/// </summary>
/// <param name="nums"></param>
/// <param name="target"></param>
/// <returns></returns>
public int[] TwoSum2(int[] nums, int target)
{
var length = nums.Length;
// 冒泡排序
var numsIndex = new int[length];
for(var i=0; i<length; i++)
{
numsIndex[i] = i;
}
for (var i=0; i<length; i++)
{
for(var j=i+1; j<length; j++)
{
if(nums[j] < nums[i])
{
var tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
// 交换的同时,交换index,以便最终出index
tmp = numsIndex[i];
numsIndex[i] = numsIndex[j];
numsIndex[j] = tmp;
}
}
}
var p1 = 0;
var p2 = length - 1;
// ..... 原双指针逼近法,返回的时候用numsIndex返回而已。
return null;
}
本地跑一下,发现本地要100ms,比第一个效果还差,看来冒泡排序严重影响了性能,并且辅助数组的处理也占用了大量的性能。不上leetCode测了,浪费时间。
既然知道是排序浪费时间多,那么可以用更高效的排序算法,但这块个人觉得,个人写的再好,也没有语言自带的排序性能高,于是想到了一个投机取巧的办法:
干脆组一个对象,把原始index和数字封装起来,按照数字排序和计算,最后输出index。这样对象可以用linq进行排序。
不废话,动手试一下:(关键代码)
public class kv
{
public int Index;
public int Value;
}
public int[] TwoSum(int[] nums, int target)
{
var length = nums.Length;
var numsList = new List<kv>();
for (var i = 0; i < length; i++)
{
numsList.Add(new kv()
{
Index = i,
Value = nums[i]
});
}
var numsArray = numsList.OrderBy(a => a.Value).ToArray();
// 原双指针逼近算法
......
}
继续本地,ut都通过,然后看10000这个case的时间:8.44ms,效果不错哦,上LeetCode试一下?效果有提升,跑了几次,最好一次108ms没有截下来
既然有效果,提交试一下吧,submit!!!
总结:
虽然是一道简单的题,但实际上要认真起来也不简单,在以下3个层次上一步步提高:
- 第一层次:普通的算法,时间复杂度O(
),类似于冒泡算法的,就可以给结果搞出来,中规中矩
- 第二层次:排序后的双指针逼近算法,这个效率高很多,但因为题目限制返回的是原始的index,为了凑出来原始的index,导致前序排序和index的处理耗时太长,结果反而效果不如上一个的普通算法;
- 第三层次:在想办法优化了排序算法后,结果性能(本地UnitTest)从88ms提升到8.4ms,性能有了极大的提升。虽然看起来只有10倍,但这是在10000的基础上的,到10万,100万,这个差距更大。因为双指针逼近算法,将 O(
)的时间复杂度,降低到了O(1)的时间复杂度,全列表只要扫描一遍即可。至于增加的排序算法,有大把优化的排序算法可以用。