leetcode-1, 两数之和

一 题目

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

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

示例:

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

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

二 题解

1. 冒泡排序

最简单、直接的解法。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    if (i == j) {//因为题目中的要求不能使用重复数据的
                        break;
                    }
                    System.out.println("answer is :" + i + " " + j);
                    int ans[] = {i, j};
                    return ans;
                }
            }
        }
        return null;
    }
}

不过冒泡排序是每一次外层循环后，选定一个数的位置。但是当前问题并非排序，所以可以稍微简化一些

...
//因为相加不改变位置，所以若1,3位相加比对过，就不需要再比对3,1位
            for (int j = i+1; j < nums.length; j++) {
...

2 掩码查找

虽然拿到这个问题的第一反应是冒泡排序，但是这只是在考虑用遍历所有可能性的方式来解决问题，实际上，分析这个问题就能轻易地发现，它并非一个排序问题。（提升对问题的分析能力）
结合题解中的“查找”思路，想到用位数来代表一个数，比如：如果有10，就在第10位上置1。查找的时候就用掩码来比较，至于int [] = {1,1}; target=2的情况，只要先查找在存储，就可以找到。

比如：[1,8,10] target = 9：
WHEN:
----position = 0, x = 1, y=9-1, recoding= 0
----CHECK 2^y & recoding != 0
----recoding | 2^1
WHEN
----position = 1, x=8, y=9-1, recoding=2^0
----CHECK 2^1 & recoding

但是这个方法的缺陷和容易忽视的点如下：

• 找到存在的数字，但是不知道数字是在第几位。只好在确认有值后再循环一遍保存过的所有数
• 数值是有负值的，只用一个地址空间没办法同时存储
• 只能应对 -63~63 之间的数

    /**
     * hahaha 被发现程序只能面对-63~63之间的数了，所以加了一个若>63时候的循环查找。但是结果比冒泡查找更慢了233333 需要的空间更多了hahahahahahahaha
     * 如果有负值，咋存呢，就再用一个long存
     * @param nums
     * @param target
     * @return
     */
    private int[] solution4(int[] nums, int target) {
        long recoding_positive = 0;
        long recoding_negative = 0;
        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            int x = nums[i];
            int y = target - x; //需要找的
            long is_exist = 0;

            if (Math.abs(x) > 63 || Math.abs(y) > 63) {//单纯用掩码查找的方式不足以存储存储绝对值在64以上的数
                if (map.containsKey(y)) {
                    return new int[] { map.get(y), i };
                }
                map.put(x, i);
            }

            //先找
            if (y >= 0) {
                is_exist = recoding_positive & (1 << y);
            }
            if (y <= 0) {//y为负值，用绝对值找
                is_exist = recoding_negative & (1 << Math.abs(y));
            }
            if (is_exist > 0) {//如果存在，那么就要从i之前的数来找到j
                for (int j = 0; j < i; j++) {
                    if (nums[i] + nums[j] == target) {
                        return new int[]{j, i}; } } }

            //如果没找到，更新recoding
            if (x >= 0) {
                recoding_positive = recoding_positive | (1 << x);
            }
            if (x <= 0) {
                recoding_negative = recoding_negative | (1 << Math.abs(x));
            }

        }
        return null;
    }

3. 数据结构——哈希表

三 知识点

1. 数组的初始化

//                    int ans[] = {i, j};
//                    return ans;                    
                    return new int[]{i, j};

HashSet、ArrayList双大括号初始化

ArrayList<Integer> set = new ArrayList<>();
set.add(1);
set.add(2);
set.add(3);

ArrayList<String> friends = new ArrayList<String>() {{
        add("Harry");
        add("Tony");
        add("Tom");
    }};
    
ArrayList<String> friends = new ArrayList<String>(Arrays.asList("a","b","c"));

2. java的位级运算

1<<10; // 2^10=1024
2 | 2 //= 2;
1 | 2 //= 3;
1 & 2 //= 0;
3 & 1 //= 1

3. HashMap