算法题1 — 寻找两数之和为目标值

题目

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

解法一

直接循环两次求和比较是否和要求的目标值一致，一致的话打印出来

public int[] twoSum(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 循环无非是遍历所有的元素，看哪个元素等于 sub ，时间复杂度为 O（n）。

有没有一种方法，不用遍历就可以找到元素里有没有等于 sub 的？

hash table ！！！

我们可以把数组的每个元素保存为 hash 的 key，下标保存为 hash 的 value 。

这样只需判断 sub 在不在 hash 的 key 里就可以了，而此时的时间复杂度仅为 O（1）！

需要注意的地方是，还需判断找到的元素不是当前元素，因为题目里讲一个元素只能用一次。

public int[] twoSum(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（2n）

空间复杂度：所谓的空间换时间，这里就能体现出来， 开辟了一个 hash table ，空间复杂度变为 O（n）

解法三

看解法二中，两个 for 循环，他们长的一样，我们当然可以把它合起来。复杂度上不会带来什么变化，变化仅仅是不需要判断是不是当前元素了，因为当前元素还没有添加进 hash 里。

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

/**
 * @author zxn
 * @ClassName TwoSum
 * @Description
 * @createTime 2023年05月23日 22:16:00
 * 示例1：输入：nums = [2,7,11,15], target = 9
 *       输出：[0,1]
 *
 * 示例2：输入：nums = [3,2,4], target = 6
 *       输出：[1,2]
 *
 * 示例3：输入：nums = [3,3], target = 6
 *       输出：[0,1]
 */
public class TwoSum {
    public static void main(String[] args) {
        int[] arr = {3,3};
        int target = 6;
        int[] ret = twoSum(arr,target);
        System.out.println("ret:");
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }
    }

    private static int[] twoSum(int[] arr, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        int[] ret = new int[2];
        for (int i = 0; i < arr.length; i++) {
            int i1 = target - arr[i];
            if (map.containsKey(i1)){
                ret[0] = i;
                ret[1] = map.get(i1);
                return ret;
            }
            map.put(arr[i],i);
        }
        return ret;
    }
}

时间复杂度：比解法一少了一次 for 循环，降为 O（n）

空间复杂度：所谓的空间换时间，这里就能体现出来， 开辟了一个 hash table ，空间复杂度变为 O（n）

总结

题目比较简单，毕竟暴力的方法也可以解决。唯一闪亮的点就是，时间复杂度从 O（n²）降为 O（n） 的时候，对 hash 的应用，有眼前一亮的感觉。

题目链接

https://leetcode.cn/problems/two-sum/