【初级算法】--1.已知两数之和,返回数组下标

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

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

下面提供三种写法,我只写出了第一种,学习后两种方法优秀的思维方式写高质量的代码。

    /**
     *暴力法   
     * @param nums 数组
     * @param target 两数之和
     * @return 数组元素索引
     */
    public static int[] method1(int[] nums, int target){
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if (nums[i]== target-nums[j]) {
                    System.out.println(i+"-----"+j);
                    return new int[] {i,j};
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

分析:
时间复杂度:O(n^2)O(n
对于每个元素,我们试图通过遍历数组的其余部分来寻找它所对应的目标元素,这将耗费 O(n)O(n) 的时间。因此时间复杂度为 O(n^2)O(n
空间复杂度:O(1)O(1)。


    /**
     * @param nums 数组
     * @param target 两数之和
     * @return 两个下标
     */
    public static int[] method2(int[] nums, int target){
        HashMap<Integer ,Integer> numbers=new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
         numbers.put(nums[i],i);
        }

        for (int i = 0; i < nums.length; i++) {
            int reaminKey= target-nums[i];

            if (numbers.containsKey(reaminKey) && numbers.get(reaminKey)!=i) {
                int value = numbers.get(reaminKey);
                 System.out.println(i+"-----"+value);
                return new int[] {i,value};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

分析:
在第一次迭代中,我们将每个元素的值和它的索引添加到hashmap中。
* 然后,在第二次迭代中,我们将检查每个元素所对应的目标元素(target - nums[i])是否存在于hashmap中。
* 注意,该目标元素不能是 nums[i]本身!
时间复杂度:O(n), 我们把包含有 nn 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1) ,所以时间复杂度为 O(n)。
空间复杂度:O(n), 所需的额外空间取决于哈希表中存储的元素数量,该表中存储了 n 个元素。


/**
  * @param nums 数组
 * @param target 两数之和
 * @return 两个下标
 */
public static int[] method3(int[] nums, int target){
    HashMap<Integer ,Integer> numbers=new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int reaminKey= target-nums[i];
        if (numbers.containsKey(reaminKey)) {
            int value = numbers.get(reaminKey);
            System.out.println(i+"-----"+value);
            return new int[] {i,value};
        }
        numbers.put(nums[i],i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

分析:
在进行迭代并将元素插入到hashmap中的同时,
我们还会回过头来检查hashmap中是否已经存在当前元素所对应的目标元素。
如果它存在,那我们已经找到了对应解,并立即将其返回。
时间复杂度:O(n),我们只遍历了包含有 nn 个元素的列表一次。在表中进行的每次查找只花费 O(1)O(1) 的时间。
空间复杂度:O(n),所需的额外空间取决于hashmap中存储的元素数量,该hashmap最多需要存储 nn 个元素。

以上代码笔者已经过验证,读者阅后可以自行亲测,欢迎交流, 一起写高质量的代码。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页