LeetCode-Easy-001-Two sum

描述

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].

难度

Easy

题目链接：

https://leetcode.com/problems/two-sum/

思路

最简单的方式是遍历，对元素 i，将其与 i+1 到 n 的元素求和判断是否等于结果。此时复杂度为 O(n²).

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; ++i) {
            for (int j = i + 1; j < nums.length; ++j) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return null;
    }
}

另一种方式是使用 HashMap 存储遍历的元素，然后遍历到 i 的时候到哈希表中寻找满足与 num[i] 求和之后等于 target 的元素，

    public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        Integer pos;
        for (int i=0, size=nums.length; i<size; i++) {
            int left = target - nums[i];
            if ((pos = map.get(left)) != null) {
                return new int[]{pos, i};
            } else {
                map.put(nums[i], i);
            }
        }
        return null;
    }

上面这种方式，不考虑哈希表查找的复杂度，遍历一次复杂度是 O(n)，所以，最终的复杂度是 n*哈希表查找的复杂度 .

当然，做过 Android 开发的会知道 SparseArray 工具类，它也可以实现哈希表的功能。好处是不需要对整形进行包装，坏处是查找的时候使用二分法，不如哈希表效率高。下面是它的实现方式，

    private static int[] twoSum(int[] nums, int target) {
        SparseArray<Integer> array = new SparseArray<>();
        Integer pos;
        for (int i=0, size=nums.length; i<size; i++) {
            int left = target - nums[i];
            if ((pos = array.get(left)) != null) {
                return new int[]{i, pos};
            } else {
                array.put(nums[i], i);
            }
        }
        return null;
    }

实际开发的时候可以根据应用场景选择合适的实现方式。