【LeetCode】1 两数之和（java）—— 简单

目录

1. 题目描述

2. 算法思路

3. 算法代码

4. 运行结果

5. 时空复杂度分析

6. 延伸

---

​​​​​​1. 题目描述

        给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标（你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案）。

2.  算法思路

注意：数组中同一个元素在答案里不能重复出现（遍历时只需要在x后面的元素中寻找target-x）。

题目分析：

    做题顺序：
        ① 读题（关注点：整数数组、和为目标值的那两个整数、每种输入只对应一个答案、同一
个元素不能重复出现） 
        ② 看示例，演算示例中的结果是否与自己想的一致（注意：数组下标默认是从0开始，但有
些算法从示例中可以看出数组下表是从1开始的） 
        ③ 做题（属于什么类型？数组；使用什么方法？暴力枚举、哈希表）

方法一：暴力枚举法
    
    思想：
        1）枚举数组中的每一个数x，寻找数组中是否存在target-x。

        2）我们只需要遍历整个数组寻找target-x。

        3）注意：每一位在x之前的元素已经和x匹配过（不需要重复匹配）
    
    处理：
        1）使用两层for循环，外层枚举每一个数x，内层寻找x后面的target-x。
        2）nums[i]+nums[j]==target时，i、j即是我们要找的和为目标值的下标（数组下标从0
开始）。
    
    缺点：寻找target-x的时间复杂度较高

方法二：哈希表法（能够快速寻找数组中是否存在目标元素） 
    
    思想：
        1）哈希表：能够快速寻找数组中是否存在目标元素target-x（时间复杂度从暴力枚举的O(N)
降低到O(1)），如果存在，找出对应的索引。
    
    处理：
        1）创建一个哈希表：
            Map<Integer, Integer> map = new HashMap<Integer, Integer>()
        2）对于数组中的每一个x，首先查询哈希表中是否存在target-x
        3）若存在，返回对应索引；若不存在，将x插入到哈希表中（x和对应下标）

    优点：能够快速寻找数组中是否存在目标元素（以后遇到类似问题，可以优先考虑哈希表）  

3. 算法代码

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

/**
 * @Author: 张晴晴
 * @Date: 2021/12/11 13:43
 * @Description: 两数之和（暴力枚举/哈希表）
 */
public class 两数之和1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        String[] strs = str.split(" ");
        int[] digits = new int[strs.length];
        for (int i = 0; i < digits.length; i++) {
            digits[i] = Integer.parseInt(strs[i]);
        }
        int target = scanner.nextInt();
        System.out.println(Arrays.toString(twoSumHash(digits, target)));
    }

    /**
     * 暴力枚举 O(N^2) O(1)
     *
     * @param nums   整数数组
     * @param target 整数目标值
     * @return 数组下标（满足数组中和为目标值target的那两个整数的数组下标）
     */
    public static int[] twoSum(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];
    }

    /**
     * 哈希表 O(N) O(N)
     *
     * @param nums   整数数组
     * @param target 目标值
     * @return
     */
    public static int[] twoSumHash(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]), i};
            }
            map.put(nums[i], i);
        }
        return new int[0];
    }
}

4. 运行结果

         输入内容：第一行为整数数组nums，第二行为目标值target，第三行和第四行分别为两种方法的运行结果。

5. 时空复杂度分析

1）暴力枚举：
    时间复杂度：O(N^2)，N是数组中的元素数量，最坏情况下数组中任意两个数都要被匹配一次。
    空间复杂度：O(1)
2）哈希表：
    时间复杂度：O(N)，N是数组中的元素数量，对于每一个元素x，寻找target-x为O(1)。
    空间复杂度：O(N)，主要为哈希表的开销。

6. 延伸

        数组下标从1开始呢？

        同一个元素可以在结果中重复出现呢？