Two Sum

Example:

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

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

#include <bits/stdc++.h>
#include <map>
#include <vector>
using namespace std;

class Solution
{
  public:
    vector<int> twoSum(vector<int> &numbers, int target)
    {
        unordered_map<int, int> hash;
        vector<int> result;
        for (int i = 0; i < numbers.size(); i++)
        {
            int numberToFind = target - numbers[i];
            if (hash.find(numberToFind) != hash.end())
            {
                result.push_back(hash[numberToFind] + 1);
                result.push_back(i + 1);
                return result;
            }
            hash[numbers[i]] = i;
        }
        return result;
    }
};
int main()
{
    vector<int> v;
    int target;
    int num;
    while (cin >> num)
    {
        if (num == 0)
            break;
        v.push_back(num);
    }
    cin >> target;
    Solution sol;
    vector<int> result;
    result = sol.twoSum(v, target);
    cout << result[0] << " " << result[1] << endl;
    return 0;
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

class Solution {

    public int[] twoSum(int[] numbers, int target) {
        int[] result = new int[2];
        Map<Integer, Integer> map = new HashMap<>(); //其中用到互加性
        for (int i = 0; i < numbers.length; i++) {
            if (map.containsKey(target - numbers[i])) {    //通过map检查是否存在符合的值，若存在将索引赋给result[1]
                result[1] = i;
                result[0] = map.get(target - numbers[i]);
                return result;
            }
            map.put(numbers[i], i);
        }
        return result;
    }
}

public class TwoSum {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        ArrayList<Integer> array = new ArrayList<>();
        while (!input.hasNext("0")) {
            array.add(Integer.valueOf(input.next()));
        }
        Scanner read = new Scanner(System.in);
        Integer target = read.nextInt();
        int[] d = new int[array.size()];
        for (int i = 0; i < array.size(); i++) {
            d[i] = array.get(i);
        }
        Solution sol = new Solution();
        int[] result = sol.twoSum(d, target);
        System.out.printf("%d	 %d", result[0], result[1]);

    }
}

调用了getNode(hash(key), key)方法，tab[(n - 1) & hash]执行了如下操作：
1. 指针first指向那一行数组的引用（那一行数组是通过table下标范围n-1和key的hash值计算出来的），若命中，则通过下标访问数组，时间复杂度为O(1)
2. 如果没有直接命中（key进行hash时，产生相同的位运算值），存储方式变为红黑树，那么遍历树的时间复杂度为O(n)。

/**
     * Implements Map.get and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // 直接命中
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            // 未命中
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }