JavaLeedCode新手村学习1

JavaLeedCode新手村学习之第一天 day01

一.1.两数之和

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

给定的代码：

class Solution {
        public int[] twoSum(int[] nums, int target) {
        
	}
}

示例 1：

输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] ==
9 ，返回 [0, 1] 。

我的解题思路
从这个示例上可以看出，可以对给定的数据进行穷举，用if判断对值判断，如果有正确的值则返回值对应的索引下标
实现代码：

class Solution {
        public int[] twoSum(int[] nums, int target) {
        //nums = [2,7,11,15], target = 9 
        //第一层循环:用于获取nums数组的每一位数
        for(int i = 0;i<nums.length;i++){
        //第二层循环:用于获取nums的每一位数与第一层循环的数相加
        	for(int j = i + 1;j<nums.length;j++){
        	//如果数组中有符合题目要求的情况，则返回下标
        		if(nums[i] + nums[j] == target){
        			return new int[]{i,j};
				}
        	}
        }
        //如果遍历完后都没有符合要求的，直接返回null
        return null;
	}
}

到这里，这一题就算成功解决了，但是我近期刚好学到了Map双列集合系列，发现这道题好像可以用键值对来更快的找到我们想要的值

实现代码：

class Solution {
        public int[] twoSum(int[] nums, int target) {
        //创建一个Map集合
        Map<Integer,Integer> m = new HashMap<>();
        //遍历数组
        for(int i = 0;i<nums.length;i++){
        //如果9-num[i]所得到的值在集合中存在，则返回下标
        	if(m.containsKey(target - nums[i])){
        	//返回满足条件的下标
				return new int[]{m.get(target - nums[i]),i};
			}
        //以数组的值为键，索引为值添加至集合中
        m.put(nums[i],i);
        }
    //如果遍历完后都没有符合要求的，直接返回null
	return null;
	}
}

参考官方题解后，发现误差不大，第一题就成功解决了，其中第二种解法使用到的containsKey方法是HashMap中的一个方法

containsKey

public boolean containsKey(Objectkey)

如果此映射包含对于指定键的映射关系，则返回 true。
指定者： 接口 Map<K,V> 中的 containsKey
覆盖： AbstractMap<K,V> 中的 containsKey
参数： key - 要测试其是否在此映射中存在的键
返回： 如果此映射包含对于指定键的映射关系，则返回 true。

二.7.整数反转

题目： 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [$-2^{31}$, $2^{31}-1$] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = -123 输出：-321

我的解题思路
从示例中可以看出，只需要对1一个给定的数进行反转就行，但是符号不变，用取模的符号即可完成题目

％ 取模（取余）
左操作数除以右操作数的余数
123%10等于3

class Solution {
    public int reverse(int x) {
 int newNum = 0;
        int tempNum;
        while (x != 0) {
            tempNum = x % 10;//取余
            x = x /10;//去尾
            newNum = newNum *10 + tempNum;//拼接
        }
        return newNum;
    }
}

但是题目中还提到，给定的数是有范围的，所以还需要对这个范围进行判断

class Solution {
    public int reverse(int x) {
        int newNum = 0;
        while (x != 0) {
            if (newNum < Integer.MIN_VALUE || newNum > Integer.MAX_VALUE) {
                return 0;
            }
            int tempNum = x % 10;
            x /= 10;
            newNum = newNum * 10 + tempNum;
        }
        return newNum;
    }
}

三.9.回文数

题目： 给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
例如，121 是回文，而 123 不是。

示例 1：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

我的解题思路
从示例和题目可以知道，只需要对x判断正反是否相同即可，所以可以用字符串进行判断

class Solution {
    public boolean isPalindrome(int x) {
    //如果x为负数则直接返回false
        if (x < 0) {
            return false;
        }
        //将x转为字符串
        String t = x + "";
        //str用于拼接字符串
        String str = "";
        for (int i = t.length() - 1; i >= 0; i--) {
            str = str + t.charAt(i);
        }
        //比较与原字符串是否相同
        return t.equals(str);
    }
}

在提交后，发现运行时间在18ms往上，而其他大佬的速度只需要5ms
大佬的代码：

class Solution {
    public boolean isPalindrome(int x) {
     //如果x为负数则直接返回false
        if(x<0){
            return false;
        }
        //用String中的valueOF方法将x转化为字符串
        String s = String.valueOf(x);
        int i=0;
        int j=s.length()-1;
        while(i<=j){
            //截取字符串：
            //利用charAt：
            //对字符串的首尾进行判断，如果对称位置的首尾不相同则返回false
            if(s.charAt(i)==s.charAt(j)){
                i++;
                j--;
            }else{
                return false;
            }
        }
        return true;

    }
}

看完大佬的代码后，发现自己的思路还要慢慢学习改进！

四.13.罗马数字转整数

题目： 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值
I           1
V          5
X          10
L          50
C          100
D          500
M          1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。

我的解题思路：
首先观察一组罗马数字的规则：如LIVII,这个罗马数字的值为56，而这个罗马数字可以拆分一下，变成L+IV+I+I，而IV这个数字又可以等价于前一个数字-I+V，最后，这个罗马数字的值计算过程就是L-I+V+I+I=50-1+5+1+1=56
所以只需要判断一个罗马数字的当前字符与后一个字符的关系即可以决定用加法还是减法
实现代码：

public int romanToInt(String s) {
        //1.添加规则
        HashMap<Character,Integer> hm = new HashMap<>();
        hm.put('I',1);
        hm.put('V',5);
        hm.put('X',10);
        hm.put('L',50);
        hm.put('C',100);
        hm.put('D',500);
        hm.put('M',1000);

        //2.求罗马数字的和
        int sum = 0;
        int len = s.length();//len = 5
        for (int i = 0; i < len; i++) {
            Integer value = hm.get(s.charAt(i));
            //判断当前字符是否是最后一个字符，以及与后一个字符的大小关系
            //如果当前字符小于后一个字符，则用减法
            if (i < len - 1 && hm.get(s.charAt(i)) < hm.get(s.charAt(i + 1))){
                sum = sum - value;
            }else {//如果当前字符大于后一个字符，则用加法
                sum = sum + value;
            }
        }
        return sum;
    }

今天的学习就结束啦！