LeetCode代码刷题（9~16）

目录

9. 回文数

10. 正则表达式匹配

11. 盛最多水的容器

12. 整数转罗马数字

13. 罗马数字转整数

14. 最长公共前缀

15. 三数之和

16. 最接近的三数之和

---

【写在前面】

前文参考：LeetCode代码刷题（1~8）

9. 回文数

题目：

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

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

例如，121 是回文，而 123 不是。
 

示例 1：

输入：x = 121
输出：true
示例 2：

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

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

提示：

-231 <= x <= 231 - 1

进阶：你能不将整数转为字符串来解决这个问题吗？

代码：

package com.my.test;

import java.util.Scanner;

public class isPalindrome {

    public static void main(String[] args) {
        System.out.print("请输入要检查的数字/字符串：");
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        System.out.println(x);

        if(isPalindrome(x)){
            System.out.println("该数字/字符串是回文数");
        }else {
            System.out.println("该数字/字符串不是回文数");
        }
    }

    //方案一：将整数转换为字符串来解决
//    public static boolean isPalindrome(int x){
//        String str =  Integer.toString(x);
//        char[] a = str.toCharArray();
//        String strReverse = "";
//        for(int i=str.length()-1; i>=0; i--){
//            strReverse = strReverse + a[i];
//        }
//        boolean result = str.equals(strReverse);
//        return result;
//    }


    //方案二：不将整数转换为字符串来解决。
    // 数学思维：最高位等于最后1位，第2高位等于倒数第2位...相当于把原数所有位数调换一下，再看是否相等。
    public static boolean isPalindrome(int x){
       int tmp = x;
       int a = 0;

       if(x < 0){   //如果是负数，则肯定不为回文数
           return false;
       }else {
           while(tmp > 0){
               a = a*10 + tmp%10;  //调换要判断的数值的位置，比如123变成321，赋给a
               tmp = tmp/10;
           }
           if(a == x){
               return true;
           }else {
               return false;
           }
       }
    }
}

输出：

请输入要检查的数字/字符串：1234321
1234321
该数字/字符串是回文数

Process finished with exit code 0

10. 正则表达式匹配

题目：

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

 
示例 1：

输入：s = "aa", p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。
示例 2:

输入：s = "aa", p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3：

输入：s = "ab", p = ".*"
输出：true
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
 

提示：

1 <= s.length <= 20
1 <= p.length <= 30
s 只包含从 a-z 的小写字母。
p 只包含从 a-z 的小写字母，以及字符 . 和 *。
保证每次出现字符 * 时，前面都匹配到有效的字符 

代码：

package com.my.test;

import java.util.Scanner;

public class isMatch {
    public static void main(String[] args) {
        System.out.println("请输入要检查的模式串和匹配串：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        String pattern = scanner.nextLine();
        System.out.println("模式串："+pattern);
        System.out.println("匹配串："+str);

        if(isMatch(str, pattern)){
            System.out.println("字符串"+str+"匹配模式串"+pattern);
        }else {
            System.out.println("字符串"+str+"不匹配模式串"+pattern);
        }

    }

    //递归的思想进行匹配
    public static boolean isMatch(String str, String pattern){
        //如果模式串为空，则看匹配串。如果匹配串也为空，则匹配成功
        if(pattern.isEmpty()){
            return str.isEmpty();
        }

        //检查第一个字符是否匹配
        boolean first_match = !str.isEmpty() && (str.charAt(0)==pattern.charAt(0) || pattern.charAt(0)=='.');

        if(pattern.length()>=2 && pattern.charAt(1)=='*'){  //如果pattern[1]是'*'
            //删除匹配串中的第一个字符，或者忽略模式串中带星号的这部分
            return ((first_match && isMatch(str.substring(1), pattern) || isMatch(str, pattern.substring(2))));
        }else { //如果pattern中没有'*'
            return (first_match && isMatch(str.substring(1), pattern.substring(1)));
        }
    }
}

输出：

请输入要检查的模式串和匹配串：
aab
aa.*
模式串：aa.*
匹配串：aab
字符串aab匹配模式串aa.*

Process finished with exit code 0

11. 盛最多水的容器

题目：

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

 

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1
 

提示：

n == height.length
2 <= n <= 105
0 <= height[i] <= 104

代码：

/*
思路：
1. 开始先假设：初始的最大的长方形面积max，长是头尾（数组首位和末尾）之差，高为头尾两数中的最小值
2. 头为head, 尾为tail。对比head和tail, 若head小，则head++。若tail小，则tail--。
3. 得到的面积跟初始最大面积max进行比较，如果新面积大，则更新最大面积max。
4. 直至比较到head==tail。得出最大面积。
 */


package com.my.test;

public class maxArea {

    public static void main(String[] args) {
        int[] height = {1,8,6,2,5,4,8,3,7};
        System.out.println("盛水最多的容器的面积是：" + maxArea(height));
    }

    public static int maxArea(int[] height){
        int head = 0;
        int tail = height.length-1;
        int max = 0;
        int tmp = 0;

        while(head != tail){
            //int l = tail - head;
            tmp = Math.min(height[head], height[tail]) * (tail - head);
            if(tmp > max){
                max = tmp;
            }

            if(height[head]<height[tail]){
                head++;
            }else {
                tail--;
            }
        }
        return max;
    }
}

输出：

盛水最多的容器的面积是：49

Process finished with exit code 0

 

12. 整数转罗马数字

题目：

罗马数字包含以下七种字符： 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:

输入: num = 3
输出: "III"
示例 2:

输入: num = 4
输出: "IV"
示例 3:

输入: num = 9
输出: "IX"
示例 4:

输入: num = 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.
示例 5:

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

提示：

1 <= num <= 3999

代码：

package com.my.test;

import java.util.Scanner;

public class intToRoman {

    public static void main(String[] args) {
        System.out.println("请输入要转换的整数：");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();

        String str = intToRoman(num);
        System.out.println("转换后的罗马数为：" + str);

    }

    public static String intToRoman(int num){
        //用两个数组，建立起一个整数和罗马数的对应表，数值从大到小
        //罗马数字由7个单字母符号组成，加上减法规则得出的6个情况,总共13个独特的符号
        int[] numbers = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        String[] str = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};

        //因为转换后的罗马数，其实就是字符串，在生成该字符串的过程中，需要不断追加字符，且String，因此这里用StringBuffer
        StringBuffer sb = new StringBuffer();

        //遍历整数数组
        for(int i=0; i<numbers.length; i++){
            while(num >= numbers[i]){
                sb.append(str[i]);
                num = num - numbers[i];
            }
            if(num == 0){
                break;
            }
        }
        return sb.toString();
    }
}

输出：

请输入要转换的整数：
4
转换后的罗马数为：IV

Process finished with exit code 0

请输入要转换的整数：
58
转换后的罗马数为：LVIII

Process finished with exit code 0

请输入要转换的整数：
98
转换后的罗马数为：XCVIII

Process finished with exit code 0

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。
 

给定一个罗马数字，将其转换成整数。

 

示例 1:

输入: s = "III"
输出: 3
 

示例 2:

输入: s = "IV"
输出: 4
 

示例 3:

输入: s = "IX"
输出: 9
 

示例 4:

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

示例 5:

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

提示：

1 <= s.length <= 15
s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
关于罗马数字的详尽书写规则，可以参考 罗马数字 - Mathematics 。

代码：

package com.my.test;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class romanToInt {

    public static void main(String[] args) {
        System.out.println("请输入要转换的罗马数字：");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();

        int num = romanToInt(str);
        System.out.println("转换后的整数为：" + num);
    }

    public static int romanToInt(String str){
        Map<Character, Integer> map = new HashMap<>(16);
        map.put('I', 1);
        map.put('V', 5);
        map.put('X', 10);
        map.put('L', 50);
        map.put('C', 100);
        map.put('D', 500);
        map.put('M', 1000);

        int length = str.length();
        int num = 0;
        for(int i=0; i<length; i++){
            Integer left = map.get(str.charAt(i));
            if(i+1<length && left<map.get(str.charAt(i+1))){
                num = num - left;   //从左到右，字符如果是升序，则做减法
            } else {
                num = num + left;   //从左到右，字符如果是降序，则做加法
            }
        }
        return num;
    }
}

输出：

请输入要转换的罗马数字：
MCMXCIV
转换后的整数为：1994

Process finished with exit code 0

14. 最长公共前缀

题目：

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

示例 2：

输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。
 

提示：

1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

代码：

package com.my.test;

public class longestCommonPrefix {

    public static void main(String[] args) {
        String[] strs = {"flower","flow","flight"};
//        String[] strs = {"dog","racecar","car"};

        String commonPrefix = longestCommonPrefix(strs);
        if(commonPrefix.length() == 0){
            System.out.println("该数组中的字符串没有公共前缀");
        } else {
            System.out.println(commonPrefix);
        }
    }

    public static String longestCommonPrefix(String[] strs){
        if(strs.length == 0){
            return "";
        }

        //找出数组中最短的字符串
        int shortLength = strs[0].length();
        int index = 0;
        for(int i=0; i<strs.length; i++){
            if(shortLength > strs[i].length()){
                shortLength = strs[i].length();
                index = i;
            }
        }

        //比较前缀
        String str = strs[index];
        for(int j=0; j<strs.length; j++){
            //如果数组中其他字符串不是以str开头，即完整的str不是其他字符串的前缀时，截短str，继续比较
            while(!strs[j].startsWith(str)){
                str=str.substring(0, str.length()-1);
            }
        }
        return str;
    }
}

输出：

fl

Process finished with exit code 0

该数组中的字符串没有公共前缀

Process finished with exit code 0

15. 三数之和

题目：

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例 2：

输入：nums = []
输出：[]

示例 3：

输入：nums = [0]
输出：[]
 

提示：

0 <= nums.length <= 3000
-105 <= nums[i] <= 105

代码：

package com.my.test;

import java.util.*;

public class threeSum {

    public static void main(String[] args) {
        System.out.println("待检查的数组为：");
        System.out.print("[");
        int[] array = {-1,0,1,2,-1,-4};
        for(int i=0; i<array.length; i++){
            if(i==array.length-1){
                System.out.print(array[i]);
            } else {
                System.out.print(array[i]+",");
            }
        }
        System.out.println("]");

        System.out.println("原始数组中，满足和为0且不重复的三元组为：");
        System.out.print("[");
        List<List<Integer>> result = threeSum(array);
        for (int j=0; j<result.size(); j++){
            if(j==result.size()-1){
                System.out.print(result.get(j));
            } else {
                System.out.print(result.get(j) + ",");
            }
        }
        System.out.println("]");
    }

    public static List<List<Integer>> threeSum(int[] nums){
        //数组排序，升序
        Arrays.sort(nums);
        //数组长度
        int l = nums.length;
        // 定义Set集合，集合里放多个List(结果).
        // 利用Set去重的特性，确保里面保存的多个结果List不重复
        Set<List<Integer>> hashSet = new HashSet<>();

        //遍历数组
        for(int i=0; i<l; i++){
            //固定nums[i]为第i个,然后从第i+1到末尾的多个数中，逐个比对，找出符合条件的
            int left = i+1;
            int right = l-1;

            while(left < right){
                if((nums[i] + nums[left] + nums[right]) == 0){  //如果找到符合“三数之和”的情况，则将三个数转为List, 然后添加到集合Set中
                    hashSet.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    left++;
                    right--;
                } else if ((nums[i] + nums[left] + nums[right]) < 0){   //如果“三数之和”小于0，则left加一，移到下一个更大的数值（因为是升序）, 再次比较
                    left++;
                } else {    //如果“三数之和”大于0，则right减一，左移到更小的数（因为是升序），再次比较
                    right--;
                }
            }
        }

        //因为返回值是一个List<List<Integer>>, 所以这里需要将集合Set中的多个List, 添加到返回值List中
        ArrayList<List<Integer>> result = new ArrayList<>();
        result.addAll(hashSet);

        return result;
    }
}

输出：

待检查的数组为：
[-1,0,1,2,-1,-4]
原始数组中，满足和为0且不重复的三元组为：
[[-1, -1, 2],[-1, 0, 1]]

Process finished with exit code 0

  

16. 最接近的三数之和

题目：

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

示例 2：

输入：nums = [0,0,0], target = 1
输出：0
 

提示：

3 <= nums.length <= 1000
-1000 <= nums[i] <= 1000
-104 <= target <= 104

代码：

package com.my.test;

import java.util.Arrays;

public class threeSumClosest {
    public static void main(String[] args) {
        System.out.print("待检查的数组为：");
        System.out.print("[");
        int[] nums = {-1,2,1,-4};
        for(int i=0; i<nums.length; i++){
            if(i == nums.length-1){
                System.out.print(nums[i]);
            } else {
                System.out.print(nums[i]+",");
            }
        }
        System.out.println("]");
        int target = 1;
        System.out.println("目标值为：" + target);

        System.out.println("与target最接近的三数之和为：" +  threeSumClosest(nums, target));
    }

    public static int threeSumClosest(int[] nums, int target){
        Arrays.sort(nums);
        int closestSum = nums[0] + nums[1] + nums[2];

        for(int i=0; i<nums.length-2; i++){
            int left = i+1;
            int right = nums.length-1;
            while(left < right){
                int threeSum = nums[i] + nums[left] + nums[right];
                //如果三数之和比预设的closestSum更接近target, 则更新closestSum
                if(Math.abs(threeSum - target) < Math.abs(closestSum - target)){
                    closestSum = threeSum;
                }

                //更新left,right
                //如果三数之和已经等于target, 则肯定是最接近target的，直接返回target
                if(threeSum < target){
                    left++;
                } else if(threeSum > target){
                    right--;
                } else {
                    return target;
                }
            }
        }
        //如果上面没有找到跟target相等的三数之和，则在这里返回最接近的三数之和
        return closestSum;
    }
}

输出：

待检查的数组为：[-1,2,1,-4]
目标值为：1
与target最接近的三数之和为：2

Process finished with exit code 0