leetcode_数据结构_入门_1. 两数之和

1. 两数之和

问题

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

分析

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


代码


main函数

package DataStructure_start;

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

public class DS20230110 {

    public static void main(String[] args) {
        int[] nums = {2,7,11,15};
        int[] a = twoSum(nums,9);
        int[] b = twoSum2(nums,22);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
    }
}

//    方法一：暴力解法

/*

思路

最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。
当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。
而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。


复杂度分析

时间复杂度：O(N^2)，其中 N 是数组中的元素数量。
         最坏情况下数组中任意两个数都要被匹配一次。
空间复杂度：O(1)

*/

    public static int[] twoSum(int[] nums, int target) {

        int n = nums.length;

//        数x对应下标
        for (int i = 0; i < n; ++i) {
//            数x后的数的下标
            for (int j = i + 1; j < n; ++j) {
//                判断两数之和是否等于目标数
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }

/*
补充：

++i与i++

    var a, i = 10;
    a = i ++; // a = 10 i = 11 先执行赋值，再自增。语句执行后a=i, i = i + 1;
    a = ++i; //a = 11, i = 11 i先自增，再执行赋值。语句执行后i = i + 1  a = i;


打印中的++i与i++

    var i = 10;
    console.log(i++); //10 ，先引用原值，然后加1

    等价于：

     var i= 10;
     console.log(i);   //先输出i
     i++;              //然后加1


for循环中 ++n 和 n ++ 执行结果是一样的

=========================================================================

Arrays.toString(a)
随机生成数组

public static String toString(int[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

*/　

/*
    方法二：哈希表

    思路

    注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。
    快速寻找数组中是否存在目标元素。
    如果存在，我们需要找出它的索引。
    使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。

    这样我们创建一个哈希表（通过计算一个关于键值的函数（散列函数），将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度），
    对于每一个 x，
    我们首先查询哈希表中是否存在 target - x，
    然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。


    复杂度分析

    时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
    空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。

*/

    public static int[] twoSum2(int[] nums, int target) {

        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();

        for (int i = 0; i < nums.length; ++i) {
//            判断集合中是否包含指定的键（查询哈希表中是否存在 target - x，）
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
//            将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
//            疑问？为什么不先把 x 插入到哈希表里？而是在插入 target - x 之后再插入？
//                    并没有插入 target - x ，因为 target 是已知的，所以只需要找到 x  ，另一个数就是 target - x
//                    将 x 插入到哈希表中的目的是 只为了增加效率，既然找到了 x ，也知道 target，就可以得出 target - x
//                    关键在于清楚地知道此处使用哈希表的原因和用途
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }

/*
补充：

    Map（双列集合）
        key不允许重复，value可以重复
        containsKey：判断集合中是否包含指定的键
        setKey方法：将Map集合中的key值，存储到Set集合
                    用迭代器或foreach循环遍历Set集合来获取Map集合的每一个key，
                        Set集合（Set集合是由一串无序的，不能重复得相同类型元素构成的集合）
                    并使用get（key）方法来获取value值

    哈希表
        哈希函数，Entry数组（扩容两倍）
        哈希冲突，链地址法
        哈希查找的时间复杂度为 O(1)

*/

参考：

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。