两数之和

两数之和

• 题目描述：
  

• 方法一：

  • 暴力枚举
    • 思路及算法:
      • 最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。

        package SumOfTwoNumbers;//暴力枚举:
        //        思路及算法:
        //        最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。
        //        当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，
        //        因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。
        
        //复杂度分析:
        //        时间复杂度：O(N^2)，其中 NN 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
        //        空间复杂度：O(1)。
        
        import java.util.Scanner;
        
        public class SumOfTwoNumbers01 {
            public static void main(String[] args) {
                Scanner input = new Scanner(System.in);
                System.out.print("Enter an integer array: ");
                String[] arr = input.next().toString().split(",");
                System.out.print("Enter a target: ");
                int target = input.nextInt();
                int[] nums = new int[arr.length];
                for (int i = 0;i < arr.length;i++)
                    nums[i] = Integer.parseInt(arr[i]);
                int[] nums2 = twoSum(nums,target);
                System.out.println("[" + nums2[0] + "," + nums2[1] + "]");
            }
            public static int[] twoSum(int[] nums,int target){
                int len = nums.length;
        
                for (int i = 0;i <len - 1;i++){
                    for (int j = i + 1;j < len;j++){
                        if (nums[i] + nums[j] == target){
                            return new int[]{i,j};
                        }
                    }
                }
                throw  new IllegalArgumentException("No two sum solution");
            }
        }
        
        

    • 复杂度分析:
      • 时间复杂度：O(N^2)，其中 NN 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
      • 空间复杂度：O(1)。

• 方法二：

  • 哈希表:
    • 思路及算法:
      • 注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

        package SumOfTwoNumbers;//哈希表:
        //        思路及算法:
        //        注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。
        //        因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。
        //        如果存在，我们需要找出它的索引。
        //        使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N)O(N) 降低到 O(1)O(1)。
        //        这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，
        //        然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
        
        //复杂度分析:
        //        时间复杂度：O(N)，其中 NN 是数组中的元素数量。对于每一个元素 x，我们可以 O(1)O(1) 地寻找 target - x。
        //        空间复杂度：O(N)，其中 NN 是数组中的元素数量。主要为哈希表的开销。
        
        
        import java.util.HashMap;
        import java.util.Map;
        import java.util.Scanner;
        
        public class SumOfTwoNumbers02 {
            public static void main(String[] args) {
                Scanner input = new Scanner(System.in);
                System.out.print("Enter an integer array: ");
                String[] arr = input.next().toString().split(",");
                System.out.print("Enter a target: ");
                int target = input.nextInt();
                int[] nums = new int[arr.length];
                for (int i = 0;i < arr.length;i++)
                    nums[i] = Integer.parseInt(arr[i]);
                int[] nums2 = twoSum(nums,target);
                System.out.println("[" + nums2[0] + "," + nums2[1] + "]");
            }
            public static int[] twoSum(int[] nums,int target){
                int len = nums.length;
                Map<Integer,Integer> hasMap = new HashMap<>(len - 1);
                hasMap.put(nums[0],0);
                for (int i = 1;i < len;i++){
                    int another = target - nums[i];
                    if (hasMap.containsKey(another)){
                        return new int[]{hasMap.get(another),i};
                    }
                    hasMap.put(nums[i],i);
                }
                throw  new IllegalArgumentException("No two sum solution");
            }
        }
        
        

    • 复杂度分析:
      • 时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1）地寻找 target - x。
      • 空间复杂度：O(N)，其中 N是数组中的元素数量。主要为哈希表的开销。