leetCode 1 Two Sum

https://leetcode.windliang.cc/ 第一時間發佈

題目描述 （簡單難度）

給定一個數組和一個目標和，從數組中找兩個數字相加等於目標和，輸出這兩個數字的下標。

解法一

簡單粗暴些，兩重循環，遍歷全部狀況看相加是否等於目標和，若是符合直接輸出。

public int[] twoSum1(int[] nums, int target) {
        int []ans=new int[2];
        for(int i=0;i<nums.length;i++){
            for(int j=(i+1);j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    ans[0]=i;
                    ans[1]=j;
                    return ans;
                }
            }
        }
        return ans;
    }

時間複雜度：兩層 for 循環，O（n²）

空間複雜度：O（1）

解法二

在上邊的解法中看下第二個 for 循環步驟。

for(int j=(i+1);j<nums.length;j++){
    if(nums[i]+nums[j]==target){

咱們換個理解方式：

for(int j=(i+1);j<nums.length;j++){ 
    sub=target-nums[i]
     if(nums[j]==sub){

第二層 for 循環無非是遍歷全部的元素，看哪一個元素等於 sub ，時間複雜度爲 O（n）。

有沒有一種方法，不用遍歷就能夠找到元素裏有沒有等於 sub 的？

hash table ！！！

咱們能夠把數組的每一個元素保存爲 hash 的 key，下標保存爲 hash 的 value 。

這樣只需判斷 sub 在不在 hash 的 key 裏就能夠了，而此時的時間複雜度僅爲 O（1）！

須要注意的地方是，還需判斷找到的元素不是當前元素，由於題目裏講一個元素只能用一次。

public int[] twoSum2(int[] nums, int target) {
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],i);
        }
        for(int i=0;i<nums.length;i++){
            int sub=target-nums[i];
            if(map.containsKey(sub)&&map.get(sub)!=i){
                return new int[]{i,map.get(sub)};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

時間複雜度：比解法一少了一個 for 循環，降爲 O（n）

空間複雜度：所謂的空間換時間，這裏就能體現出來， 開闢了一個 hash table ，空間複雜度變爲 O（n）

解法三

看解法二中，兩個 for 循環，他們長的同樣，咱們固然能夠把它合起來。複雜度上不會帶來什麼變化，變化僅僅是不須要判斷是否是當前元素了，由於當前元素尚未添加進 hash 裏。

public int[] twoSum3(int[] nums, int target) {
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            int sub=target-nums[i];
            if(map.containsKey(sub)){
                return new int[]{i,map.get(sub)};
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

總結

題目比較簡單，畢竟暴力的方法也能夠解決。惟一閃亮的點就是，時間複雜度從 O（n²）降爲 O（n） 的時候，對 hash 的應用，有眼前一亮的感受。