One brush 144 force deduction hot question-1 sum of two numbers (E)

 subject ：
 Given an array of integers  nums  And an integer target value  target,
 Please find... In the array   And is the target value  target   the   Two   Integers , And return their array subscripts .

 You can assume that each input corresponds to only one answer . however , The same element in the array cannot be repeated in the answer .
 You can return the answers in any order .
--------------
 Example ：
 Input ：nums = [2,7,11,15], target = 9
 Output ：[0,1]
 explain ： because  nums[0] + nums[1] == 9 , return  [0, 1] .
 Example  2：

 Input ：nums = [3,2,4], target = 6
 Output ：[1,2]
 Example  3：

 Input ：nums = [3,3], target = 6
 Output ：[0,1]
----------------------
 reflection ：
 Solution 1 ： Violent search 
 Algorithm description 
 Two loops , The first cycle takes a number from front to back nums[i], Second cycle search target - nums[i] Whether in the remaining elements .
 Complexity of time and space 
 The time complexity is O(n^2). Without considering the original array , The space complexity is O(1).
 Code 
class Solution {
    
    public int[] twoSum(int[] nums, int target) {
    
        if (nums == null || nums.length == 0) return new int[]{
    };
        for (int i = 0; i < nums.length; i++) {
    
            for (int j = i + 1; j < nums.length; j++) {
    
                if (nums[i] == target - nums[j]) {
    
                    return new int[]{
    i, j};
                }
            }
        }
        return new int[]{
    };
    }
}
 Solution 2 ： Hashtable 1
 Algorithm description 
 Set the original array element value (key) And its subscripts (value) After saving a hash table , Traverse... With a loop nums,
 With O(1) The time complexity is found in the hash table map.containsKey(target - nums[i]).

 Complexity of time and space 
 Storing the original array into the hash table costs O(n) Time , Loop traversal cost O(n) Time ,
 Each location of hash table only costs O(1) Time , So the time complexity is O(n).

 The hashtable consumes space O(n), So the space complexity is zero O(n).

 Code 
class Solution {
    
    public int[] twoSum(int[] nums, int target) {
    
        if (nums == null || nums.length == 0) {
    
            return new int[]{
    };
        }
        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 need = target - nums[i];
            if (map.containsKey(need)) {
    
                if (i != map.get(need)) {
    
                    return new int[]{
    i, map.get(need)};
                }
            }
        }
        return new int[]{
    };
    }
}

LC