Leetcode刷题日记1

两数之和

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

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

示例:

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

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

这道题我第一反应就是暴力解法，

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] test=new int[2];
        for(int i=0;i<nums.length-1;i++)
        {
            for(int j=i+1;j<nums.length;j++)
            {
                if((nums[i]+nums[j])==target)
                {
                    test[0]=i;
                    test[1]=j;
                    return test;
                }
            }
        }
        throw new IllegalArgumentException("Not found");
    }
}

官方给的最高效的方法是一遍Hashmap

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-2/

也就是说，遍历的同时，查看放入Hashmap中的的数是否有符合的。
这种方法时间复杂度是按照最理想的情况算的——没有hash冲突

整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:

输入: 123 输出: 321 示例 2:

输入: -123 输出: -321 示例 3:

输入: 120 输出: 21 注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 −
1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer

这里提供两种方法。第一种是官方的，第二种是大神写的。
官方就是比较中规中矩

class Solution {
    public int reverse(int x) {
        int rev=0;
        int pop=0;
        while(x!=0){
            pop=x%10;
            x/=10;
            if(rev>Integer.MAX_VALUE/10||(rev==Integer.MAX_VALUE/10&&rev+7==Integer.MAX_VALUE)) return 0;
            if(rev<Integer.MIN_VALUE/10||(rev==Integer.MIN_VALUE/10&&rev-8==Integer.MIN_VALUE)) return 0;
                rev=rev*10+pop;
        }
        return rev;
    }
}

2³¹-1个位数字为7，2³¹个位数字为8所以需要+7和减8来进行判断是否移除
第二种方法，干脆直接利用数字溢出，溢出之后数字肯定不会和原数字相同

class Solution {
    public int reverse(int x) {
       int ans = 0;
	while (x != 0) {
		if ((ans * 10) / 10 != ans) {
			ans = 0;
			break;
		}
		ans = ans * 10 + x % 10;
		x = x / 10;
	}
	return ans;
}}

因为考虑的是反转之后是否溢出，所以可以在反转数中调用一位之前先判断，*10会不会溢出。这里可能会有人钻牛角尖：*10之后不会溢出，也就是临界值214748364，这个时候，*10是不会溢出的，但是我加上的数字是0-9小于10，这个时候就可能溢出。
首先int的范围边界的个位数分别是7和8，也就是说最后一位得是大于等于7。但是你把这个数字变成原来的数字，你会发现原数已经超出int范围，所以根本不可能存在这样的数字。