力扣LeetCode，两数之和

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

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

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

我的答案：

package com.leetcode;

/**
 *
 */
public class NumsTarget {

    /**
     * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
     * <p>
     * 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
     *
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        // 可以定义一个长度为2的数组
        int[] resultNums = new int[2];
        // 循环遍历nums的int类型的数组
        for (int i = 0; i < nums.length; i++) {
            // 从第i+1的位置开始进行循环遍历
            for (int j = i + 1; j < nums.length; j++) {
                // 判断，如果第i个位置的数组元素和第i+1个位置的数组元素之和，如果和目标值target相等
                if (nums[i] + nums[j] == target) {
                    // 就将下标索引的值放到数组中
                    resultNums[0] = i;
                    resultNums[1] = j;
                }
            }
        }
        // 返回存放索引的数组
        return resultNums;
    }

    public static void main(String[] args) {
        // 定义一个数组，将几个数组元素添加到数组中
        int[] nums = new int[]{2, 7, 11, 15};
        // 初始化一个目标值
        int target = 18;

        // 创建一个NumsTarget对象
        NumsTarget numsTarget = new NumsTarget();
        // 调用方法，将参数传递进去
        int[] twoSum = numsTarget.twoSum(nums, target);
        // 循环遍历获取到的索引值元素
        for (int i = 0; i < twoSum.length; i++) {
            System.out.println(twoSum[i]);
        }
    }

}

效果截图：

 

2、力扣LeetCode给的标准答案。

2.1、方案一，暴力法。暴力法很简单。遍历每个元素x，并查找是否存在一个值与target−x相等的目标元素。

package com.leetcode;

/**
 *
 */
public class NumsTarget {

    /**
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        // 循环遍历数组
        for (int i = 0; i < nums.length; i++) {
            // 依次遍历第i+1个值
            for (int j = i + 1; j < nums.length; j++) {
                // 如果第i个元素的值和第i+1个元素的值之和等于目标值target。
                // 或者第i+1个元素的值等于目标值减去第i个元素的值。
                if (nums[j] == target - nums[i]) {
                    // 返回创建的存储索引元素值的数组
                    return new int[]{i, j};
                }
            }
        }
        // 抛出异常
        throw new IllegalArgumentException("No two sum solution");
    }

    public static void main(String[] args) {
        // 定义一个数组，将几个数组元素添加到数组中
        int[] nums = new int[]{2, 7, 11, 15};
        // 初始化一个目标值
        int target = 18;

        // 创建一个NumsTarget对象
        NumsTarget numsTarget = new NumsTarget();
        // 调用方法，将参数传递进去
        int[] twoSum = numsTarget.twoSum(nums, target);
        // 循环遍历获取到的索引值元素
        for (int i = 0; i < twoSum.length; i++) {
            System.out.println(twoSum[i]);
        }
    }

}

方案一，复杂度分析：

1）、时间复杂度：O(n^2)，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费O(n)的时间。因此时间复杂度为O(n^2)。
2）、空间复杂度：O(1)。

 

2.2、方案二、两遍哈希表。

　　为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。
　　通过以空间换取速度的方式，我们可以将查找时间从O(n)降低到 O(1)。哈希表正是为此目的而构建的，它支持以 近似 恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n)。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1)。

　　一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素（target−nums[i]）是否存在于表中。注意，该目标元素不能是nums[i]本身！

package com.leetcode;

import java.util.HashMap;
import java.util.Map;

/**
 *
 */
public class NumsTarget {

    /**
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        // 创建一个Map集合对象
        Map<Integer, Integer> map = new HashMap<>();
        // 根据数组nums的长度，将所有的数组元素和数据的索引存储到Map集合中
        for (int i = 0; i < nums.length; i++) {
            // key是元素的值，value是索引的值
            map.put(nums[i], i);
        }
        // 循环遍历数组
        for (int i = 0; i < nums.length; i++) {
            // 使用目标值减去数组元素的值
            int complement = target - nums[i];
            // 使用目标值减去数组元素的值，判断Map集合中是否包含该key的值，并且该key值的value不能等于本身，即不重复
            if (map.containsKey(complement) && map.get(complement) != i) {
                // 返回i的值，和包含该complement这个key的value值
                return new int[]{i, map.get(complement)};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

    public static void main(String[] args) {
        // 定义一个数组，将几个数组元素添加到数组中
        int[] nums = new int[]{2, 7, 11, 15};
        // 初始化一个目标值
        int target = 18;

        // 创建一个NumsTarget对象
        NumsTarget numsTarget = new NumsTarget();
        // 调用方法，将参数传递进去
        int[] twoSum = numsTarget.twoSum(nums, target);
        // 循环遍历获取到的索引值元素
        for (int i = 0; i < twoSum.length; i++) {
            System.out.println(twoSum[i]);
        }
    }

}

方案二，复杂度分析：

1）、时间复杂度：O(n)，我们把包含有n个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1)，所以时间复杂度为O(n)。
2）、空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了n个元素。

 

2.3、方案三，一遍哈希表。

　　事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

package com.leetcode;

import java.util.HashMap;
import java.util.Map;

/**
 *
 */
public class NumsTarget {

    /**
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        // 创建一个Map集合
        Map<Integer, Integer> map = new HashMap<>();
        // 循环遍历数组
        for (int i = 0; i < nums.length; i++) {
            // 使用目标值减去数组元素的值
            int complement = target - nums[i];
            // 判断Map集合中是否包含该key的值，此算法的精髓所在，将数组元素放入到Map集合中，然后使用使用目标值减去下一个数组元素的值和Map集合中的key值进行判断
            if (map.containsKey(complement)) {
                // 返回i的值，和包含该complement这个key的value值
                return new int[]{map.get(complement), i};
            }
            // 将数组元素的值和索引值存放到Map集合中
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }

    public static void main(String[] args) {
        // 定义一个数组，将几个数组元素添加到数组中
        int[] nums = new int[]{2, 7, 11, 15};
        // 初始化一个目标值
        int target = 18;

        // 创建一个NumsTarget对象
        NumsTarget numsTarget = new NumsTarget();
        // 调用方法，将参数传递进去
        int[] twoSum = numsTarget.twoSum(nums, target);
        // 循环遍历获取到的索引值元素
        for (int i = 0; i < twoSum.length; i++) {
            System.out.println(twoSum[i]);
        }
    }

}

方案三，复杂度分析：

1）、时间复杂度：O(n)，我们只遍历了包含有n个元素的列表一次。在表中进行的每次查找只花费O(1)的时间。
2）、空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储n个元素。

作者：别先生

博客园：https://www.cnblogs.com/biehongli/

如果您想及时得到个人撰写文章以及著作的消息推送，可以扫描上方二维码，关注个人公众号哦。