LeetCode算法第一题：：两数之和

/**
 * @Auther: chenxiuqi
 * @Date: 2020/5/13 13:27
 * @Description:两数之和
 * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 *
 * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
 *
 *  
 *
 * 示例:
 *
 * 给定 nums = [2, 7, 11, 15], target = 9
 *
 * 因为 nums[0] + nums[1] = 2 + 7 = 9
 * 所以返回 [0, 1]
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/two-sum
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class SumOfTwoNumbers {

    /**
     * 暴力解决法
     *
     * 暴力法很简单，遍历每个元素 xx，并查找是否存在一个值与 target - x 相等的目标元素。
     *
     * 复杂度分析：
     *          时间复杂度：O(n²)
     *                   对于每个元素通过遍历数组的其余部分，来寻找目标元素，这将耗费O(n) 的时间，因此时间复杂度是 O(n)
     *          空间复杂度：O(1)
     *
     */
    public static int[] twoSum1(int[] nums, int target) {

        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {

                if (nums[i]==target-nums[j]){
                    return new int[]{i,j};
                }
                
            }
        }
        System.out.print("没找到");
        return null;
    }


    /**
     * 哈希二遍法
     *
     *         时间复杂度：O(n)
     *                  由于哈希表把时间缩短到 O(1)，所以时间复杂度是 O(n)
     *         空间复杂度：O(n)
     *                  所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 nn 个元素
     *
     */
    public static int[] twoSum2(int[] nums, int target) {

        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i],i);
        }

        for (int j = 0; j < nums.length; j++) {
            int num = target-nums[j];
            if (map.containsKey(num)){
                return new int[]{map.get(num),j};
            }
        }
        System.out.print("没找到");
        return null;
    }


    /**
     * 哈希一遍法
     *
     *          时间复杂度：O(n)，
     *                  我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。
     *
     *          空间复杂度：O(n)，
     *                  所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。
     *
     */
    public static int[] twoSum3(int[] nums, int target) {

        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int num = target-nums[i];
            if (map.containsKey(num)){
                return new int[]{map.get(num),i};
            }
            map.put(nums[i],i);
        }
        System.out.print("没找到");
        return null;
    }


    public static void main(String[] args) {
        int[] nums = {1,2,7,9,11};
        int target = 12;
        System.out.println("暴力方式一：");
        Arrays.stream(SumOfTwoNumbers.twoSum1(nums,target)).forEach(x->System.out.print(x+"\t"));
        System.out.println("\n\n===============================\n\n");
        System.out.println("哈希二遍法：");
        Arrays.stream(SumOfTwoNumbers.twoSum2(nums,target)).forEach(x->System.out.print(x+"\t"));
        System.out.println("\n\n===============================\n\n");
        System.out.println("哈希一遍法：");
        Arrays.stream(SumOfTwoNumbers.twoSum3(nums,target)).forEach(x->System.out.print(x+"\t"));
        System.out.println();
    }

}