LeetCode哈希表篇【两数之和】

力扣题目链接(opens new window)

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

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

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

正解

1）双指针法

class Solution {
        public int[] twoSum(int[] nums, int target) {
        int first = 0;
        int end = nums.length-1;
        int ret[] = new int[2];
        int index[]=new int[nums.length];//记录原始数组的下标
        for (int i = 0; i < index.length; i++) {
            index[i]=i;
        }
        quickSort(nums,0,nums.length-1,index);//快速排序，并同时记录下标变化
        while (first != end) {//双指针寻找
            if (nums[first] + nums[end] > target) {
                end--;
            } else if (nums[first] + nums[end] < target) {
                first++;
            } else {
                ret[0]=index[first];
                ret[1]=index[end];
                break;
            }
        }
        return ret;
    }

    public void quickSort(int[] arr, int low,int high,int index[]) {
        // low,high 为每次处理数组时的首、尾元素索引

        // 当low==high是表示该序列只有一个元素，不必排序了
        if (low >= high) {
            return;
        }
        // 选出哨兵元素和基准元素。这里左边的哨兵元素也是基准元素base
        int i = low, j = high;int base = arr[low];
        while (i < j) {
            // 右边哨兵从后向前找
            while (arr[j] >= base && i < j) {
                j--;
            }
            // 左边哨兵从前向后找
            while (arr[i] <= base && i < j) {
                i++;
            }
            swap(arr, i, j,index); // 交换元素
        }
        swap(arr, low, j,index); // 基准元素与右哨兵交换,此时i=j,左右哨兵代表的一致，哪个都行

        // 递归调用，排序左子集合和右子集合
        quickSort(arr, low, j - 1,index);
        quickSort(arr, j + 1, high,index);
    }

    private void swap(int[] arr, int i, int j,int index[]) {
        int soon=index[i];
        index[i]=index[j];
        index[j]=soon;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

将其数组转为有序，然后利用双指针缩小范围；由于其返回的是原数组的下标，因而在排序时还要记录其原数组的位置；该方法对本题不是十分适合，稍显麻烦，主要为回顾快速排序。

2）哈希Map

两数之和为target，且数组必有答案；所以可以理解为在数组中找一个nums[i]=target-num[j];此时用HashMap来记录其下标并判断是否存在最为合适。key用来存值，value用来存下标。

public int[] twoSum(int[] nums, int target) {
    int[] res = new int[2];
    Map<Integer, Integer> map = new HashMap<>();
    for(int i = 0; i < nums.length; i++){
        int temp = target - nums[i];
        if(map.containsKey(temp)){
            res[1] = i;
            res[0] = map.get(temp);
        }
        map.put(nums[i], i);
    }
    return res;
}