LeetCode_两数之和（三种解法-Java）

两数之和 TwoSum

题目：

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

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

解答：

方法一：循环遍历法/暴力破解法（也叫穷举法，它的时间复杂度为O（n^2））

package leetcode;

public class TwoSum {//力扣—两数之和
    public int[] twoSum(int[] nums, int target) {
        for (int i=0;i<nums.length;i++){//循环遍历数组
            for (int j=i+1;i<nums.length;j++){//循环遍历i后面的数值
                if (nums[i]+nums[j]==target){//循环判断前一个值加上后一个值，是否等于目标值
                    return new int[]{i,j};//满足条件则返回响应的下标
                }
            }
        }
     return new int[]{-1,-1};//如果找不到响应的值，就返回该值
    }

    public static void main(String[] args) {
        TwoSum twoSum = new TwoSum();
        int[] array = new int[]{2,7,11,15};
        int target = 9;
        int[] result = twoSum.twoSum(array,target);
        System.out.println(Arrays.toString(result));
    }
}

控制台输出的结果如下图所示：

方法二：倒推法。（通过map的数据结构，简化查询时间。时间复杂度为O（n））

package leetcode;

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

public class Test1 {//力扣—两数之和
    public int[] twoSum(int[] nums, int target) {
        //创建map集合
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for (int i=0;i<nums.length;i++){//循环将数组的值存入map集合中
            map.put(nums[i],i); //将数组里面的值作为key存储，相对应的索引用存入value中
        }
        for (int i = 0; i < nums.length; i++) {//循环遍历数组的值
            int needNum = target-nums[i];//用目标值减去数组里面遍历的值，得到相应的值
            if (map.containsKey(needNum) && needNum!=i){//判断得到的值是否在数组里面,且不重复
                return new int[]{i,map.get(needNum)};//返回下标
            }
        }
     return new int[]{-1,-1};//如果找不到相应的值，就返回该值
    }

    public static void main(String[] args) {
        Test1 twoSum = new Test1();
        int[] array = new int[]{2,7,11,15};
        int target = 9;
        int[] result = twoSum.twoSum(array,target);
        System.out.println(Arrays.toString(result));
    }
}

控制台如下图输出：（仍旧是一样的）

方法三：（时间复杂度：O（n））与方法二类似，其区别是方法三并没有先把值存放进集合里面，而是先找寻集合里是否有对应的值，没有则按照数组的顺序把值存放进去，在循环找寻，以此类推。

举个栗子： int[] array = new int[]{2,7,11,15}; 假设目标值 target=26.
map集合里面未存任何值，循环遍历一遍，map中没有值，将数组中2存入map里。
26-2=24？ -->map{2} 把7存进去
26-7=19？—>map{2,7} 把11存进去
26-11=15？—>map{2,7,11} 把15存进去
26-15=11？—>map{2,7,11,15} 在数组中找到11+15=26（目标值）,因而返回对应的下标。

package leetcode;
import java.util.Arrays;
import java.util.HashMap;

public class Test2 {//力扣—两数之和
    public int[] twoSum(int[] nums, int target) {/**第三种方法：一边遍历一边修改map里面的集合或者说在遍历中修改map，每次都验证下标之前的数值*/
        //创建map集合
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for (int i=0;i<nums.length;i++){
            int needNum = target-nums[i];
            if (map.containsKey(needNum)){
                return new int[]{i,map.get(needNum)};
            }
            map.put(nums[i],i);
        }
     return new int[]{-1,-1};//如果找不到相应的值，就返回该值
    }
    public static void main(String[] args) {
        Test2 twoSum = new Test2();
        int[] array = new int[]{2,7,11,15};
        int target = 9;
        int[] result = twoSum.twoSum(array,target);
        System.out.println(Arrays.toString(result));
    }
}

控制台输出的结果为：（最后的结果不影响该题的解法）

留言：欢迎各位小伙伴们的评论哈 ~