【LeetCode】—— 简单的OJ题

一、LeetCode7题 整数反转

1.1 题目描述

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

示例1：

输入： 123
输出： 321

示例2：

输入： -123
输出： -321

示例3：

输入： 120
输出： 21

1.2 解题思路

• 其实思路很简单，主要理解一下这句代码 ret = ret * 10 + a;举个例子来说明一下，当x = 123时，我们先取到该数的个位，这里只需要模10求余即可，再让x/10之后取得123的十位以此类推。
• 该题还需注意的点是，必须注意反转后数字 INT_MIN < ret < INT_MAX,INT_MAX就是整型能表示的最大值，INT_MIN是整型能表示的最小值。
• ret必须定义为long类型，不然会代码会出现执行错误，我们将ret定为long类型，在返回时将ret强制类型转换为int型返回即可。
  

1.3 代码实现

class Solution {
public:
    int reverse(int x) {
       int a = 0;
        long ret = 0;
        while(x != 0)
        {
            a = x % 10;
            x = x / 10;
            ret = ret * 10 + a;
            
            if(ret < INT_MIN || ret > INT_MAX)
                return 0;
        }
        
        return (int)ret;   
    }
};

二、LeetCode9题 回文数

2.1 题目描述

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

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

示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

2.2 解题思路

验证回文数的方法有很多，这里提供三种供大家参考：

方法一：

• 借用上述反转整数的函数，将整数反转之后与原来整数比较，要是相同返回true，不同返回false，这里只需要注意处理一下负数的情况，由于负数带一个负号，所以反转之后肯定不会是回文数，我们单独除了负数，只要该数小于零返回false即可。

方法二：

• 第二种方法其实也很好理解，C++实现，击败99.58%用户，思路很简单，这里用到了一个函数就是将数字转换为字符串的函数to_string,在转换字符串之前处理两个特殊的情况，即小于零和等于零的情况,转换之后用一个for循环用两个下标，一个从头一个从尾访问字符串，比较两个字符，能走出循环，说明该数是回文数。
  
  方法三
• 这个方法就比较简单了，将整数转换为字符串之后，逆转字符串，再与原字符串对比，相等返回true，不等返回false即可。

2.3 代码实现

方法一：

class Solution {
public:
    int reverse(int x) {
		int a = 0;
		long ret = 0;
		while (x != 0)
		{
			a = x % 10;
			x = x / 10;
			ret = ret * 10 + a;

			if (ret < INT_MIN || ret > INT_MAX)
				return 0;
		}

		return (int)ret;
	}
    bool isPalindrome(int x) {
        if(x < 0)
            return false;
        int ret = reverse(x);
        
        if(ret == x)
            return true;
        else
            return false; 
    }
};

方法二：

class Solution {
public:
    bool isPalindrome(int x) {
        if(x < 0)
            return false;
        if(x == 0)
            return true;
        string str = to_string(x);
        for(size_t i = 0;i < str.size() - 1;++i)
        {
            if(str[i] != str[str.size()-i-1])
                return false;
        }
        return true;
    }
};

方法三

class Solution {
public:
    bool isPalindrome(int x) {
        if(x < 0)
            return false;
        string str = to_string(x);
        
        string rstr = str;
        reverse(rstr.begin(),rstr.end());
        
        return rstr == str;
    }
};

三、LeetCode13题 罗马数字转整数

3.1 题目描述

罗马数字包含以下七种字符: 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。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”
输出: 3

示例 2:

输入: “IV”
输出: 4

示例 3:

输入: “IX”
输出: 9

示例 4:

输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.

示例 5:

输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

3.2 解题思路

• 虽然代码看起来挺多的，但是思路很简单，因为我们只有7个罗马数字不多，这里用到了switch-case语句，这里只要将罗马数字转换为对应的十进制数字，然后相加即可
• 还是得处理特殊情况 ，若是后一个字符代表的数字是大于前一个的，就用后一个字符的值减去前一个的值 //eg：IV，4就是等于 v(5) - I(1) = 4;

3.3 代码实现

class Solution {
public:
    int romanToInt(string s) {
        int sum[50]={0},num=0;
        for(int i=0;i<s.length();i++)
        {
            switch(s[i])
            {
                case 'I':sum[i]=1;break;
                case 'V':sum[i]=5;break;
                case 'X':sum[i]=10;break;
                case 'L':sum[i]=50;break;
                case 'C':sum[i]=100;break;
                case 'D':sum[i]=500;break;
                case 'M':sum[i]=1000;break;
            }
            //若是后一个字符代表的数字是大于前一个的，就用后一个字符的值减去前一个得值
            //eg：IV，4就是等于 v(5) - I(1) = 4;
            if(i > 0&&sum[i] > sum[i-1]) 
                sum[i-1] =- sum[i-1];
        }
        //将所有字符代表的数字分别相加得到最后的数
        for(int i = 0;i < s.length();i++) 
            num = num + sum[i];
        return num;
        
    }
};

四、LeetCode66题 加一

4.1 题目描述

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

4.2 解题思路

主要可以分为三个if语句分支来处理这个题目：

• 第一个if分支处理就是比较普遍的情况，数组最后一位若是小于9，此时只需要给最后一位加上一，返回该数组即可
• 第二个if分支处理的情况就是当数组走到最前端位置时，，若是数组中的每个数位都是9，比如：[9,9,9,9,9],这是比较特殊的一种情况，此时循环处理每一位时，在没有到达最开始位，都可以将该位置0，最后在数组最前面的位置上插入一个1，此时数组为[1,0,0,0,0,0]。
• 第三个if分支处理的情况就是当数组未走到最前端，但此时该位上又是9的情况，只需要将该位置0，即可。
• 这3个if分支放在一个循环内，因为要处理的是每个数位上的情况。

4.3 代码实现

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        for(int i = digits.size() - 1;i >= 0;--i)
        {
            if(digits[i] < 9)
            {
                digits[i] += 1;
                break;//若是最后一位数不大于9，就不用考虑进位的情况
            }
            else if(i == 0 && digits[i] == 9)
            {
                digits[i] = 0;
                digits.insert(digits.begin(),1);
            }
            else if(digits[i] == 9)
            {
                digits[i] = 0;
            }
        }
        return digits;
    }
};