1. 两数之和（数组+哈希表）

1.题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9，所以返回 [0, 1]

2.C++版本-解题方法

2.1 暴力求解:算法时间复杂度O(n²)，空间复杂度O(1)

#include <iostream>
#include <vector>
using namespace std;
/*
twoSum函数目标：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
执行用时：616 ms, 在所有 C++ 提交中击败了32.76%的用户
内存消耗：9.2 MB, 在所有 C++ 提交中击败了21.05%的用户
*/
vector<int> twoSum(vector<int> &nums, int target) //这个地方是引用传递
{
    int i, j;
    for (i = 0; i < nums.size(); i++)
    {
        for (j = i + 1; j < nums.size(); j++) //j=i+1，不让同一个位置的数字相加
        {
            if (nums[i] + nums[j] == target)
            {
                return {i, j};
            }
        }
    }

    return {};
}
/*
    关于返回一个vec有另外一个简单写法
    上面是return 了一个 {}，也是vec的形式
    执行结果：
执行用时：780 ms, 在所有 C++ 提交中击败了16.98%的用户
内存消耗：9.2 MB, 在所有 C++ 提交中击败了17.76%的用户
*/
vector<int> twoSum02(vector<int> &nums, int target) //这个地方是引用传递
{
    vector<int> ans;
    int i, j;
    for (i = 0; i < nums.size(); i++)
    {
        for (j = i + 1; j < nums.size(); j++) //j=i+1，不让同一个位置的数字相加
        {
            if (nums[i] + nums[j] == target)
            {
                ans.push_back(i);
                ans.push_back(j);
                return ans;
            }
        }
    }
    return ans;
}

/*
主函数main
*/
int main(void)
{
    int nums[4] = {1, 2, 7, 6};
    vector<int> vec(nums, nums + 4);
    int target = 4;
    vector<int> res = twoSum(vec, target); //这个是vector的传引用
    //cout << vec << endl;//不能直接cout一个vector
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    return 0;
}

2.2  两次hash法

        第一次是迭代将元素插入到map中，第二次是查找；

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

/*
执行用时：20 ms, 在所有 C++ 提交中击败了59.56%的用户
内存消耗：10.4 MB, 在所有 C++ 提交中击败了5.01%的用户
*/
vector<int> getSum(vector<int> &nums, int target)
{
    unordered_map<int, int> hashmap;
    for (int i = 0; i < nums.size(); i++)
    {
        //向map中添加元素
        hashmap[nums[i]] = i;
    }
    for (int i = 0; i < nums.size(); i++)
    {
        if (hashmap.count(target - nums[i]) == 1 && hashmap[target - nums[i]] != i)
        //if (hashmap.find(target - vec[i]) !=hashmap.end() && hashmap[target - vec[i]] != i)
        {
            return {i, hashmap[target - nums[i]]};
        }
    }
    return {};
}

int main()
{
    int nums[4] = {0, 3, 2, 5};
    int target = 8;
    vector<int> vec(nums, nums + 4);
    vector<int> ans = getSum(vec, target);
    for (int i = 0; i < ans.size(); i++)
    {
        cout << ans[i] << " ";
    }
    cout << endl;
    return 0;
}

2.3 一次hash法

        在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回；

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

/*
执行用时：20 ms, 在所有 C++ 提交中击败了59.56%的用户
内存消耗：10.2 MB, 在所有 C++ 提交中击败了6.91%的用户
*/
vector<int> getSum(vector<int> &nums, int target)
{
    unordered_map<int, int> hashmap;
    for (int i = 0; i < nums.size(); i++)
    {
        if (hashmap.count(target - nums[i]) > 0)
        {
            return {hashmap[target - nums[i]], i};
        }
        hashmap[nums[i]] = i; //反过来放入map中，用来获取结果下标
    }

    return {};
}

int main()
{
    int nums[4] = {0, 3, 2, 5};
    int target = 8;
    vector<int> vec(nums, nums + 4);
    vector<int> ans = getSum(vec, target);
    for (int i = 0; i < ans.size(); i++)
    {
        cout << ans[i] << " ";
    }
    cout << endl;
    return 0;
}

3.java版本

package com.array.easy.LeetCode1;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @author GMT
 * @data 2020年10月13日
 * @version 1.0
 */
public class Solution {
	/*
	 * 方法一：暴力：直接双层for循环 小技巧是怎么返回一个一维数组：new int[] { i, j }和new int[0] 
	 * 执行用时：71 ms, 在所有Java 提交中击败了29.06%的用户 内存消耗： 38.2 MB , 在所有 Java 提交中击败了99.95%的的用户
	 */
	public int[] twoSum1(int[] nums, int target) {
		for (int i = 0; i < nums.length; i++) {
			for (int j = i + 1; j < nums.length; j++) {
				if (nums[i] + nums[j] == target)
					return new int[] { i, j };
			}
		}
		return new int[0];
	}

	/*
	 *方法二：借助于hashmap，key和value逆向思维考虑
	 * 执行用时： 3 ms , 在所有 Java 提交中击败了 73.01% 的用户   内存消耗： 38.2 MB , 在所有 Java 提交中击败了99.95%的用户
	 */
	public int[] twoSum2(int[] nums, int target) {
		Map<Integer, Integer> hashmap = new HashMap<Integer, Integer>();
		for (int i = 0; i < nums.length; i++) {
			if (hashmap.containsKey(target - nums[i])) {
				return new int[] { hashmap.get(target - nums[i]), i };
			}
			hashmap.put(nums[i], i);
		}

		return new int[0];
	}

	public static void main(String[] args) {
		Solution solution = new Solution();
		int[] nums = { 2, 4, 5, 9 };
		int target = 6;
		int[] ans1 = solution.twoSum1(nums, target);
		System.out.println("方法一执行结果：" + Arrays.toString(ans1));// 遍历数组
		int[] ans2 = solution.twoSum2(nums, target);
		System.out.println("方法二执行结果：" + Arrays.toString(ans2));// 遍历数组
	}
}