LeetCode - 1 两数之和

最新推荐文章于 2024-07-25 21:13:04 发布

kevinmartin

最新推荐文章于 2024-07-25 21:13:04 发布

阅读量195

点赞数

分类专栏：力扣 LeetCode 算法文章标签： leetcode 算法动态规划

本文链接：https://blog.csdn.net/kevinmartin/article/details/122156606

版权

算法同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

力扣 LeetCode

6 篇文章 0 订阅

订阅专栏

纠结了很久，决定从第一篇写起，每一篇都认真写，多种思路。

给定一个整数数组 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( n^2 )。其实有更快的算法，就是双指针两端逼近法。

算法图形演示：

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)的时间复杂度，全列表只要扫描一遍即可。至于增加的排序算法，有大把优化的排序算法可以用。