2018.10.13学习笔记

10.13学习笔记

今天都在复习这周大学所学的课程，做了一个静态的简历网页，还挺好看的哈哈。到了晚上才有空坐下来，上了LeetCode刷了一道简单的算法题，下面总结下这道算法题的收获。

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].
题目简单意思就是：给定一个数组和一个目标值，找出数组中两个数相加之和为目标值的两个下标，返回一个存储了两个下标的数组，但是不能使用一个相同的元素两次。

解法1：

public class solution_1 {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0;i<nums.length - 1;i++){
            for(int j = i+1;i<nums.length;j++){
                if(nums[i] + nums[j] == target){
                    return new int[]{i,j};  //直接return new int[]{i,j} 
                }
            }
        }
        throw new IllegalArgumentException("no such sum solution");//抛出一个异常就不会报没有return语句的错误
    }

    public static void main(String args[]){
        solution_1 exercise_1 = new solution_1();
        int [] sums = {2,7,11,15};
        int target = 9;
        int [] result = exercise_1.twoSum(sums,target);
        for (int e:result){
            System.out.print(e + " ");
        }
    }
}

这是最容易想到的算法，算法的时间复杂度为O(n*n),空间复杂度为O(1)。

解法2：

/*
description：trade space for speed 用空间换取时间
             two iterations: first is store array to hashMap  O(n) = n;
 */

public class solution_2 {
    public int[] twoSum(int[] sums, int target) {
        HashMap<Integer,Integer> sumsMap = new HashMap<>();
        for (int i = 0;i<sums.length;i++){
            sumsMap.put(sums[i],i);   //hashMap 只能通过key获取value，因此把sum[i]作为key
        }

        for (int j = 0;j<sums.length;j++){
            int complement = target - sums[j];
            if (sumsMap.containsKey(complement) && complement != sums[j]){
                return new int[]{j,sumsMap.get(sums[j])};
            }
        }
        throw new IllegalArgumentException("no such solution");
    }
}

第二种解法，用空间换取时间，第一次使用iterator将数组中的职存储到hashMap中，然后在hashMap中查找有没有target—sums[j]的值，由于hashMap是使用散列来实现的，所以在hashMap中查找一个元素的时间复杂度为O(1)。这种算法的时间复杂度为O(n)，空间复杂度也为O(n)。

解法3：

/*
description:use only one iterator to store array into hashMap,and varies to solution_2,solution_3 checked complement in one iterator
 */

public class solution_3 {
    public int[] twoSum(int[] sums, int target) {
        HashMap<Integer,Integer> map = new HashMap<>();
       for (int i = 0;i<sums.length;i++){
           int complement = target - sums[i];
           if (map.containsKey(complement)) {
               return new int[] { map.get(complement), i };
           }
           map.put(sums[i], i);
       }
       throw new IllegalArgumentException("no such solution");
    }
}

第三种解法优化了第二种解法，只使用了一次迭代，虽然与第二种方法的时间复杂度和空间复杂度都相同，但第三种解法明显优于第二种解法。

10.13学习笔记

猜你喜欢