Java 日常

缘鱼的Java刷题记录

记录了我刷的部分Java题（不过在AI时代还坚持练习古法编程真的有用吗...）

简单题

两数之和

标签：数组、哈希表

题目

原题链接：1. 两数之和 - 力扣（LeetCode）

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：

1
2
3

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

示例 2：

1
2

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

1
2

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

提示：

  • 2 <= nums.length <= 104
  • -109 <= nums[i] <= 109
  • -109 <= target <= 109
  • 只会存在一个有效答案

作答模版 

1
2
3
4
5

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

答案

时间复杂度为 O(n)的答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i< nums.length; i++) {
            if(map.containsKey(target - nums[i])) {
                return new int[] {map.get(target-nums[i]),i};
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

作者：画手大鹏
链接：https://leetcode.cn/problems/two-sum/solutions/6873/jie-suan-fa-1-liang-shu-zhi-he-by-guanpengchn/
来源：力扣（LeetCode）

我的菜鸡答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int i, j;
        for (i = 0; i < nums.length; i++) {
            for (j = i+1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return null;
    }
}

回文数

标签：数学

题目

原题链接：9. 回文数 - 力扣（LeetCode）

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

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

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

示例 1：

1
2

输入：x = 121
输出：true

示例 2：

1
2
3

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

示例 3：

1
2
3

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

提示：

  • -231 <= x <= 231 - 1

作答模版 

1
2
3
4
5

class Solution {
    public boolean isPalindrome(int x) {
        
    }
}

答案

力扣官方答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Solution {
    public boolean isPalindrome(int x) {
        // 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x == revertedNumber || x == revertedNumber / 10;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/palindrome-number/solutions/281686/hui-wen-shu-by-leetcode-solution/
来源：力扣（LeetCode）

我的菜鸡答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) return false;
        String strX = Integer.toString(x);
        int length = strX.length();
        for (int i = 0; i < length / 2; i++) {
            char left = strX.charAt(i);
            char right = strX.charAt(length - 1 - i);
            
            if (left != right) return false;
        }
        return true;
    }
}

罗马数字转整数

标签：哈希表、数学、字符串

题目

原题链接：13. 罗马数字转整数 - 力扣（LeetCode）

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

1
2
3
4
5
6
7
8

字符          数值
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:

1
2

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

示例 2:

1
2

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

示例 3:

1
2

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

示例 4:

1
2
3

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

示例 5:

1
2
3

输入: 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 。
  • 关于罗马数字的详尽书写规则，可以参考 罗马数字 - 百度百科。

作答模版 

1
2
3
4
5

class Solution {
    public int romanToInt(String s) {
        
    }
}

答案

力扣官方答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Solution {
    Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
        put('I', 1);
        put('V', 5);
        put('X', 10);
        put('L', 50);
        put('C', 100);
        put('D', 500);
        put('M', 1000);
    }};

    public int romanToInt(String s) {
        int ans = 0;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            int value = symbolValues.get(s.charAt(i));
            if (i < n - 1 && value < symbolValues.get(s.charAt(i + 1))) {
                ans -= value;
            } else {
                ans += value;
            }
        }
        return ans;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/roman-to-integer/solutions/774992/luo-ma-shu-zi-zhuan-zheng-shu-by-leetcod-w55p/
来源：力扣（LeetCode）

我是菜鸡，没做出来（悲）

最长公共前缀

标签：字典树、数组、字符串

题目

原题链接：14. 最长公共前缀 - 力扣（LeetCode）

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

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

示例 1：

1
2

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

示例 2：

1
2
3

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

提示：

  • 1 <= strs.length <= 200
  • 0 <= strs[i].length <= 200
  • strs[i] 如果非空，则仅由小写英文字母组成

作答模版 

1
2
3
4
5

class Solution {
    public String longestCommonPrefix(String[] strs) {
        
    }
}

答案

官方效率最高的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Solution {
    public String longestCommonPrefix(String[] strs) {
        // 1. 特殊情况：如果数组为空，直接返回空字符串
        if (strs == null || strs.length == 0) {
            return "";
        }

        // 2. 核心：把第一个字符串当作【初始的最长公共前缀】
        // 比如：["flower","flow","flight"]
        // prex 一开始 = "flower"
        String prex = strs[0];

        // 3. 遍历数组中【剩下的每一个字符串】
        // 从第 2 个开始，一个个去匹配当前前缀 prex
        for (int i = 1; i < strs.length; i++) {

            // 4. 关键：indexOf(prex) != 0
            // 意思：当前字符串【不是以 prex 开头】，就进入循环
            // indexOf(xxx) == 0 才代表【以xxx开头】
            while (strs[i].indexOf(prex) != 0) {

                // 5. 不匹配？就把前缀【删掉最后一个字符】
                // 比如 "flower" → "flowe" → "flow" → "flo" → "fl"
                prex = prex.substring(0, prex.length() - 1);

                // 6. 如果前缀缩到空了，直接返回空，没有公共前缀
                if (prex.isEmpty()) {
                    return "";
                }
            }
        }

        // 7. 遍历完所有字符串，剩下的 prex 就是【最长公共前缀】
        return prex;
    }
}

我的菜鸡答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Solution {
    public String longestCommonPrefix(String[] strs) {
        // 特殊情况：数组为空直接返回空
        if (strs == null || strs.length == 0) {
            return "";
        }

        String pub = "";
        int j = 0;

        while(j < strs[0].length()) {
            // 标记数组第一个字符串的第一个字符
            char target = strs[0].charAt(j);
            // 遍历数组
            for (int i = 1; i < strs.length; i++) {
                if (j >= strs[i].length()) return pub;
                if (target != strs[i].charAt(j)) {
                    return pub;
                }
            }
            pub += target;
            j++;
        }
        return pub;
    }
}

有效的括号

标签：栈、字符串

题目

原题链接：20. 有效的括号 - 力扣（LeetCode）

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

**输入：**s = “()”

**输出：**true

示例 2：

**输入：**s = “()[]{}”

**输出：**true

示例 3：

**输入：**s = “(]”

**输出：**false

示例 4：

**输入：**s = “([])”

**输出：**true

示例 5：

**输入：**s = “([)]”

**输出：**false

提示：

  • 1 <= s.length <= 104
  • s 仅由括号 '()[]{}' 组成

作答模版 

1
2
3
4
5

class Solution {
    public boolean isValid(String s) {
        
    }
}

答案

我参考（抄）的力扣官方答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

class Solution {
    public boolean isValid(String s) {
        int len = s.length();
        if (len % 2 == 1) {
            // 若长度是奇数则一定不匹配
            return false;
        }

        Map<Character, Character> pairs = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};

        // 创建一个栈
        Deque<Character> stack = new LinkedList<Character>();
        for (int i = 0; i < len; i++) {
            char ch = s.charAt(i);
            // 判断获取到的括号是不是右括号
            if (pairs.containsKey(ch)) {
                // 若是右括号则开始匹配
                if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
                    // 若栈为空那当然就没得匹配；
                    // 若不为空则判断当前栈顶（离它最近的左括号）是否是对应的左括号
                    // 若不匹配则返回false
                    return false;
                } else {
                    // 若成功匹配就出栈
                    stack.pop();
                }
            } else {
                // 若是左括号则入栈
                stack.push(ch);
            }
        }
        // 若栈为空，说明全部匹配后出栈了
        return stack.isEmpty();
    }
}

合并两个有序列表

标签：递归、链表

题目

原题链接：21. 合并两个有序链表 - 力扣（LeetCode）

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

image-20260409213426190

1
2

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

1
2

输入：l1 = [], l2 = []
输出：[]

示例 3：

1
2

输入：l1 = [], l2 = [0]
输出：[0]

提示：

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按 非递减顺序 排列

作答模版 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        
    }
}

答案

我抄的力扣官方答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null) {
            return list2;
        } else if (list2 == null) {
            return list1;
        } else if (list1.val < list2.val) {
            list1.next = mergeTwoLists(list1.next, list2);
            return list1;
        } else {
            list2.next = mergeTwoLists(list1, list2.next);
            return list2;
        }
    }
}

删除有序数组中的重复项

标签：数组、双指针

题目

原题链接：26. 删除有序数组中的重复项 - 力扣（LeetCode）

给你一个 非严格递增排列 的数组 nums ，请你** 原地** 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k。去重后，返回唯一元素的数量 k。

nums 的前 k 个元素应包含 排序后 的唯一数字。下标 k - 1 之后的剩余元素可以忽略。

判题标准:

系统会用下面的代码来测试你的题解:

1
2
3
4
5
6
7
8
9

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

示例 1：

1
2
3

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

1
2
3

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4,_,_,_,_,_]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

  • 1 <= nums.length <= 3 * 104
  • -100 <= nums[i] <= 100
  • nums 已按 非递减 顺序排列。

作答模版 

1
2
3
4
5

class Solution {
    public int removeDuplicates(int[] nums) {
        
    }
}

答案

官方答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-array/solutions/728105/shan-chu-pai-xu-shu-zu-zhong-de-zhong-fu-tudo/
来源：力扣（LeetCode）

我的菜鸡答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Solution {
    public int removeDuplicates(int[] nums) {
        int i = 0; 
        int j = 1;

        while(j < nums.length) {
            if (nums[i] == nums[j]) {
                // 相等时，唯一指针不变，探查指针继续往后
                j++;
            } else {
                // 不相等时，先后移唯一指针
                i++;
                // 然后将唯一指针所在数字改为探查指针所在数字
                nums[i] = nums[j];
                // 探查指针继续往后
                j++;
            }
        }

        return i+1;
    }
}

移除元素

标签：数组、双指针

题目

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

  • 更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
  • 返回 k。

用户评测：

评测机将使用以下代码测试您的解决方案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
                            // 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有的断言都通过，你的解决方案将会 通过。

示例 1：

1
2
3
4

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

示例 2：

1
2
3
4
5

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

提示：

  • 0 <= nums.length <= 100
  • 0 <= nums[i] <= 50
  • 0 <= val <= 100

作答模版 

1
2
3
4
5

class Solution {
    public int removeElement(int[] nums, int val) {
        
    }
}

答案

力扣官方答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Solution {
    public int removeElement(int[] nums, int val) {
        int n = nums.length;
        int left = 0;
        for (int right = 0; right < n; right++) {
            if (nums[right] != val) {
                nums[left] = nums[right];
                left++;
            }
        }
        return left;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-element/solutions/730203/yi-chu-yuan-su-by-leetcode-solution-svxi/
来源：力扣（LeetCode）

我的菜鸡答案：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Solution {
    public int removeElement(int[] nums, int val) {
        int i = 0;
        int n = nums.length;
        int last = n-1;

        if (n == 0) return 0;

        while(i < last) {
            if (nums[i] != val) {
                // 不相等就继续往后
                i++;
            } else {
                // 判断最后一个标记是否也等于val
                if (nums[last] != val) {
                    // 不相等则和最后一个元素互换
                    nums[i] = nums[last];
                    // 互换后标记最后一个元素的位置前移
                    last--;
                } else {
                    // 相等则把last标记前移
                    last--;
                }
                
            }
        }

        // 防nums=[1], val=1，或nums[2,2]，val=2这类情况
        if (nums[i] == val) {
            i--;
        }

        return i+1;
    }
}
© 2025 - 2026 缘鱼
本站于2025年3月26日建立
使用 Hugo 构建
主题 Stack 由 Jimmy 设计