Leetcode-两数和（java实现）

Leetcode-两数和（java实现）

题目要求

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解决方案

• 第一种：
  • 两遍for循环，遍历每一个元素x，并查找是否存在一个值与target-x相等
    时间复杂度O(n*n),空间复杂度O(1)
• 第二种：
  • 一个有效的方法检测数组中是否存在目标元素，如果存在，找出索引
  2. 保持数组与索引的最好方法是使用hash表
  3. 通过以空间换速度的方法，将查找时间从O(n)降低到（1）
  4. 再上一个方法中，一个实现使用了两个迭代，将每个元素的值和索引添加到列表中
     在第二次迭代中，检查每个元素所对应的目标元素（target-nums[i]）是否
     存在表中

4. 第三种：
   • 在进行迭代并将元素插入表中的同时检查是否已经存在当前元素所对应的目标元素
   • 如果存在，及找到解答，直接返回。

代码实现

package sort;

import java.util.Arrays;
import java.util.HashMap;
/*
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
 */
public class Solution {
    /*
    两遍for循环，遍历每一个元素x，并查找是否存在一个值与target-x相等
    时间复杂度O(n*n),空间复杂度O(1)
     */
    public static int[]  sumGetTwo(int[]arr, int target){
        return getInts(arr, target);
    }

    static int[] getInts(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j <arr.length ; j++) {
                if(arr[j] == target - arr[i]){
                    return new int[]{i,j};
                }
            }
        }
        throw new IllegalArgumentException("不合格的参数");
    }

    /*
    1. 一个有效的方法检测数组中是否存在目标元素，如果存在，找出索引
    2. 保持数组与索引的最好方法是使用hash表
    3. 通过以空间换速度的方法，将查找时间从O(n)降低到（1）
    4. 再上一个方法中，一个实现使用了两个迭代，将每个元素的值和索引添加到列表中
        在第二次迭代中，检查每个元素所对应的目标元素（target-nums[i]）是否
        存在表中
     */
    public static int[]  sumGetTwo1(int[]nums, int target){
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i],i);
        }
        for (int i = 0; i < nums.length; i++) {
            int complement = target -nums[i];
            if(map.containsKey(complement)&&map.get(complement)!=i){
                return new int[]{i, map.get(complement)};
            }
        }
        throw new IllegalArgumentException("不合格的参数");
    }
    /*
    在第二种方法中，可以一次完成。
    在进行迭代并将元素插入表中的同时检查是否已经存在当前元素所对应的目标元素
    如果存在，及找到解答，直接返回。
     */
    public static int[]  sumGetTwo2(int[]nums, int target){
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if(map.containsKey(complement)){
                return new int[]{map.get(complement),i};
            }
            map.put(nums[i],i);
        }
        throw new IllegalArgumentException("不合格的参数");
    }
    public static void main(String[] args) {
        int[] array = new int[]{1, 3, 2, 4};
        int[] ints = sumGetTwo(array, 3);
        System.out.println(Arrays.toString(ints));
        int[] ar = sumGetTwo1(array, 4);
        System.out.println(Arrays.toString(ar));
        int[] arb = sumGetTwo2(array, 4);
        System.out.println(Arrays.toString(arb));

    }
}