leetcode_1. Two Sum

leetcode_1. Two Sum

前言:

这段时间开始敲leetcode。我认为这并不仅仅只是为了应付笔试,面试。而是确实有着一定的意义。

尤其,你提交代码后,网站会多方面验证你的答案。

另外,提交成功后,你可以查看自己的运行时间,以及别人的运行时间。

最最关键的是,这之后,你可以查看别人的优秀代码。

这还不算,其中讨论模块,解决方案模块。

虽然以前在大学,玩过ACM。但是,体验和leetcode差很多。

所以,我是比较推荐的。

 

之前,我都是按照题目的序号来进行解题。

不过,其中hard难度的题目,确实对于现在的我来说有一定难度。

尤其是做到一篇寻找最长回文串的midium难度后,又做了一个判断是否为回文串的easy难度题目。

 

所以,我决定从简单的题目开始做起来。

我应该只会将一些midium难度的题目发布上来。以及一些有着不错亮点的easy题目。

 

 

一,问题:

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

翻译:

函数的输入是一个int数组以及一个目标值。通过在数组中选择两个int整数,来凑出目标值。

我们可以假设每个输入只有一个解决方案。并且数组中的每个元素只能使用一次。

(貌似,现在已经有了leetcode中文版。但是一方面,我希望锻炼一下自己的专业英文,另一方面,中文版的功能支持还不完善)

 

 

二,思路:

1.暴力法:通过双重循环,来遍历所有可能性,判断是否与目标值相等,如果相等,输入该循环内的两个数。

  优化:类比于排序算法的优化,外层循环遍历的nums[i]与内层循环遍历的nums[j],完全没必要再通过外层循环的nums[j]与内层循环的nums[i]这样来重复。

 

2.针对法:通过单次循环获取数组中每一个元素nums[i],再通过找寻数组内是否存在nums[j]使得nums[j]==target-nums[i],因为许多语言,内置了相关的搜搜索函数。如js的indexof.

 

 

三,代码:

我之后的这些题目都将采用go语言来实现。

V1:

func twoSum(nums []int, target int) []int {
    result := make([]int, 0)
    for k, v := range nums {
        for k2, v2 := range nums[k+1:] {
            if v+v2 == target {
                result = append(result, k,k2+k+1)
                return result
            }
        }
    }
    return result
}

由于并没有在go中找到相关的类似indexof的函数,所以,我便采用了暴力解法。

Runtime:80ms,6.40%

这里,我对于go的slice产生了一些疑惑,这导致我增添了一个无用的result变量。所以,我需要修改一下。

 

V2:

func twoSum(nums []int, target int) []int {
    for k, v := range nums {
        for k2, v2 := range nums[k+1:] {
            if v+v2 == target {
                return []int{k, k+k2+1}
            }
        }
    }
    return []int{}
}

PS:我们完全可以通过一句    return []int{k, k+k2+1}  来新建并返回一个匿名的slice。

Runtime:36ms,39.93%

相对与V1版本有了进步,但是仍然与TOP1的差很多。

从语法的角度,改进的空间已经不是很大了。那么只能从算法的结构上来提升。

虽然,go语言没有indexof。但是go语言还有map。

我曾今见过一两个通过map来提升速度的函数。但是,轮到自己来设计,还真是有些不适应。尤其,我对map还不是那么的熟悉,这导致我无法了解它的原理,从而降低耗时。

所以,我只能先试一试。直接先将所有的值都放在Map上,然后通过map间接性的实现indexof功能。

 

V3:

func twoSum(nums []int,target int) []int {
    m:=make(map[int]int)
    for k,v:=range nums{
        m[v]=k
    }
    for k,v:=range nums{
        another:=target-v
        k2,ok:=m[another]
        if ok== true &&k!=k2{
            return []int{k,k2}
        }
    }
    return nil
}

PS:这算是最无脑,直接的map算法。

Runtime:32ms,40.19%

即使这个算法非常无脑,只是非常僵硬地使用了map。但是依旧比v2快速。并且,这个方法从代码的角度依旧可以改进嘛。

起码两次循环遍历,完全是可以避免的。

 

V4:

 1 func twoSum(nums []int,target int) []int {
 2     m:=make(map[int]int)
 3     for k,v:=range nums{
 4         another:=target-v
 5         k2,ok:=m[another]
 6         if ok== true &&k!=k2{
 7             return []int{k,k2}
 8         }
 9         m[v]=k
10     }
11     return nil
12 }

PS:这里有一个非常关键的地方,那就是第9行的m[v]=k必须在第5行的k2,ok:=m[another]前。这样就避免了数组内有相同元素3,target=6,而导致的k2=k的情况。因为在map中相同键值的value值会后者覆盖前者的。

Runtime:8ms,85.92%

这可以说是一个非常喜人的结果了。从最后的结果分析图来看,只有一种算法要超过V4算法。

但是,我在尝试了几次代码上map的优化,还是没有办法。我甚至想是不是从内存的角度解决的。但是感觉可能性不大。

最后,简化出一个版本。

 

V5:

 1 func twoSum(nums []int,target int) []int {
 2     m:=make(map[int]int)
 3     for k,v:=range nums{
 4         another:=target-v
 5         if k2,ok:=m[another]; ok {
 6             return []int{k,k2}
 7         }
 8         m[v]=k
 9     }
10     return nil
11 }

Runtime:8ms,85.92%

虽然,简化了内存和判断条件。但是运算时间依然没有提高。甚至在一次改进中还出现时间增加到12ms的情况。

所以这应该是我提交的最终版本了。

 

 

四,他人代码:
1.最佳代码:

无论如何,也要看看完成最佳的代码是如何实现的。

 1 func twoSum(nums []int, target int) []int {
 2     m := make(map[int]int)
 3     for i := 0; i < len(nums); i++ {
 4         comp := target - nums[i]
 5         if _, ok := m[comp]; ok {
 6             return []int {m[comp], i}
 7         }
 8         m[nums[i]] = i
 9     }
10     return nil
11 }

Runtime:4ms,100%

 

2.分析:

从这个代码来看,其结构基本和我的最终版V5类似了。区别在于1,他没有使用range函数;2,他第5行没有接受key值,在第6行中采用map[key]来获取所需的value值。

那么究竟是哪个造成这4ms的差距。

但从理论上分析,我确实无法做到。但是我可以一个个去尝试嘛。

 

3.结果:

然而,在测试过程中,我发现了很尴尬的情况。那就是我的V5算法和TOP算法会跳动。有时候4ms,100%,有时候8ms,85.92%。

 

leetcode_1. Two Sum_第1张图片

结果,另外一次提交:

leetcode_1. Two Sum_第2张图片

 

请注意,下面的代码部分是完全一摸一样的。。。

表示这种情况也是有些尴尬。

不过,两者的算法应该差距不大了。

 

 

五,总结:

1,任何问题的第一要求是解决问题。不管是什么方法,想想出来一个解决问题。再谈优化。

2.任何函数都需要各种各样的测试,如溢出等。这样才可以令函数更具健壮性。

3.很多时候,go可以通过map来实现其他语言indexof的功能。而且性能很好。

4.算法结构解决完了,更可以优化代码结构。

 

PS:V4中解决键值冲突,只需要简单的换个位置就可以了。

PS2:map通过键值找不到的值,会返回相关零值。如果需要判断到底是否存在,请使用ok接收。

 

如有更正,请指出。谢谢。

(话说,for循环中到底是用i好呢,还是用range更好呢。)

转载于:https://www.cnblogs.com/Tiancheng-Duan/p/9035580.html

你可能感兴趣的:(leetcode_1. Two Sum)