leetcode-两数之和

1.题目

        Given an array of integers, return indices of the two numbers such that they add up to a specific
        target.
        You may assume that each input would have exactly one solution, and you may not use the same
        element twice.
        Example:
        Given nums = [2, 7, 11, 15], target = 9,
        Because nums[0] + nums[1] = 2 + 7 = 9,
        return [0, 1]

    题⽬⼤意
            在数组中找到 2 个数之和等于给定值的数字，结果返回 2 个数字在数组中的下标。
            解题思路
            这道题最优的做法时间复杂度是 O(n)。
            顺序扫描数组，对每⼀个元素，在 map 中找能组合给定值的另⼀半数字，如果找到了，直接返回 2 个
            数字的下标即可。如果找不到，就把这个数字存⼊ map 中，等待扫到“另⼀半”数字的时候，再取出来返
            回结果

题目假设只有一组符合条件，我自己写的是找出所有符合条件的组合。

2.解法
1.时间复杂度为o(n^2)的解法，双重循环。

//o(n^2)解法，牺牲时间
    private static Map<Integer,Integer> fun1(int[] arr, int target){
        Map<Integer,Integer> res = new HashMap<>();
        for(int i=0;i<arr.length;++i){
            for(int j=0;j<arr.length;++j){
                if((arr[i]==target-arr[j])&&(i<j)){//循环判断满足条件，但是要去除重复结果
                    res.put(i,j);
                }
            }
        }
        return res;
        }

2.时间复杂度为o(n)的解法，利用map存储数组的值及其对应的下标，牺牲空间换时间。

  //o(n)解法，牺牲空间
    public static Map<Integer,Integer> fun2(int[] arr,int target){
        //用于存储数组中每个值及其对应的下标
        Map<Integer,Integer> map = new HashMap<>();
        //用于返回所有符合条件的结果
        Map<Integer,Integer> res = new HashMap<>();
        for(int i=0;i<arr.length;++i){
            map.put(arr[i],i);
        }
        for(int j=0;j<arr.length;++j){
            if(map.containsKey(target-arr[j])&&map.get(target-arr[j])!=j&&(j<map.get(target-arr[j]))){
                res.put(j,map.get(target-arr[j]));
            }
        }
       return res;

    }

完整代码：

public class Test01 {
    //o(n^2)解法，牺牲时间
    private static Map<Integer,Integer> fun1(int[] arr, int target){
        Map<Integer,Integer> res = new HashMap<>();
        for(int i=0;i<arr.length;++i){
            for(int j=0;j<arr.length;++j){
                if((arr[i]==target-arr[j])&&(i<j)){//循环判断满足条件，但是要去除重复结果
                    res.put(i,j);
                }
            }
        }
        return res;
        }
        //o(n)解法，牺牲空间
    public static Map<Integer,Integer> fun2(int[] arr,int target){
        //用于存储数组中每个值及其对应的下标
        Map<Integer,Integer> map = new HashMap<>();
        //用于返回所有符合条件的结果
        Map<Integer,Integer> res = new HashMap<>();
        for(int i=0;i<arr.length;++i){
            map.put(arr[i],i);
        }
        for(int j=0;j<arr.length;++j){
            if(map.containsKey(target-arr[j])&&map.get(target-arr[j])!=j&&(j<map.get(target-arr[j]))){
                res.put(j,map.get(target-arr[j]));
            }
        }
       return res;

    }
    public static void main(String[] args) {
       int[] arr = new int[]{2,7,3,6,2,3,11,15};
       int target = 9;
        System.out.println("方法1=================");
       //遍历输出map
        for(int index1:fun1(arr,target).keySet()){
            System.out.println(index1+","+fun1(arr,target).get(index1));
        }
        System.out.println("方法2=================");
        for(int index1:fun2(arr,target).keySet()){
            System.out.println(index1+","+fun2(arr,target).get(index1));
        }
    }


}