慢慢开始刷leetcode。
自勉。

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

暴力搜索 残差

时间复杂度O(n**2)
空间复杂度O(1)

另外两种以HashMap为主

总结下hashmap的特点

HashMap<String, Double> map = new HashMap<String, Double>();
map.put("ss", 11.0);

每个java object 都有hashCode() 方法。
put 源码

public V put(K key, V value)   
{   
 // 如果 key 为 null，调用 putForNullKey 方法进行处理  
 if (key == null)   
     return putForNullKey(value);   
 // 根据 key 的 keyCode 计算 Hash 值  
 int hash = hash(key.hashCode());   
 // 搜索指定 hash 值在对应 table 中的索引  
     int i = indexFor(hash, table.length);  
 // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素  
 for (Entry<K,V> e = table[i]; e != null; e = e.next)   
 {   
     Object k;   
     // 找到指定 key 与需要放入的 key 相等（hash 值相同  
     // 通过 equals 比较放回 true）  
     if (e.hash == hash && ((k = e.key) == key   
         || key.equals(k)))   
     {   
         V oldValue = e.value;   
         e.value = value;   
         e.recordAccess(this);   
         return oldValue;   
     }   
 }   
 // 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry   
 modCount++;   
 // 将 key、value 添加到 i 索引处  
 addEntry(hash, key, value, i);   
 return null;   
}   

方法中Map.Entry接口也是key-value对， HashMap中完全没有考虑value，只由key的HashCode决定存储位置，再一起存储value。
indexFor 则搜索table处的索引。

static int indexFor(int h, int length)   
{   
    return h & (length-1);   
}  

当 length 总是 2 的倍数时，h & (length-1) 将是一个非常巧妙的设计：假设 h=5,length=16, 那么 h & length - 1 将得到 5；如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15；但是当 h=16 时 , length=16 时，那么 h & length - 1 将得到 0 了；当 h=17 时 , length=16 时，那么 h & length - 1 将得到 1 了……这样保证计算得到的索引值总是位于 table 数组的索引之内。

两步hash法

public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        for (int i = 0; i < nums.length; i++) {
            int res = target - nums[i];
            if (map.containsKey(res) && (map.get(res) != i)) {
                return new int[] {i, map.get(res)};
            }
        }
        return null;
   }

先将value-key存入map，再索引。
Time complexity : O(n). We traverse the list containing n elements exactly twice. Since the hash table reduces the look up time to O(1), the time complexity is O(n).

Space complexity : O(n). The extra space required depends on the number of items stored in the hash table, which stores exactly n elements.

一步法

在存入map时就检索是否存在.

public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            int res = target - nums[i];
            if (map.containsKey(res)) {
                return new int[] {map.get(res), i};
            }
            map.put(nums[i], i);
        }
        return null;
   }