LeetCode100天Day6-回文数与加一：基础数字处理与数组操作
摘要：本文详细解析了LeetCode中两道基础题目------"回文数"和"加一"。通过将整数转换为字符串的方式判断回文，以及通过字符串操作处理大整数加法，帮助读者掌握数字与字符串转换的基本技巧。
目录
文章目录
- LeetCode100天Day6-回文数与加一：基础数字处理与数组操作
-
- 目录
- [1. 回文数（Palindrome Number）](#1. 回文数（Palindrome Number）)
-
- [1.1 题目描述](#1.1 题目描述)
- [1.2 解题思路](#1.2 解题思路)
- [1.3 代码实现](#1.3 代码实现)
- [1.4 代码逐行解释](#1.4 代码逐行解释)
- [1.5 复杂度分析](#1.5 复杂度分析)
- [1.6 边界情况处理](#1.6 边界情况处理)
- [2. 加一（Plus One）](#2. 加一（Plus One）)
-
- [2.1 题目描述](#2.1 题目描述)
- [2.2 解题思路](#2.2 解题思路)
- [2.3 代码实现](#2.3 代码实现)
- [2.4 代码逐行解释](#2.4 代码逐行解释)
- [2.5 完整执行流程示例](#2.5 完整执行流程示例)
- [2.6 复杂度分析](#2.6 复杂度分析)
- [2.7 注意事项](#2.7 注意事项)
- [3. 两题对比与总结](#3. 两题对比与总结)
-
- [3.1 共同点](#3.1 共同点)
- [3.2 字符串操作技巧总结](#3.2 字符串操作技巧总结)
- [3.3 双指针算法模板](#3.3 双指针算法模板)
- [4. 总结](#4. 总结)
- 参考资源
- 文章标签
1. 回文数（Palindrome Number）
1.1 题目描述
给你一个整数 x，如果 x 是一个回文整数，返回 true；否则，返回 false。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true示例 2：
输入：x = -121
输出：false
解释：从左向右读，为 -121。从右向左读，为 121-。因此它不是一个回文数。示例 3：
输入：x = 10
输出：false
解释：从右向左读，为 01。因此它不是一个回文数。1.2 解题思路
判断回文数的最直观方法是将数字转换为字符串，然后使用双指针从两端向中间比较。
解题步骤：
- 将整数转换为字符串
- 使用头尾两个指针分别指向字符串的首尾
- 比较两个指针指向的字符，如果不相等则不是回文
- 移动指针，继续比较，直到指针相遇或交叉
1.3 代码实现
java
class Solution {
public boolean isPalindrome(int x) {
String temp = x + "";
int len = temp.length();
int head = 0;
int tail = len - 1;
while(head < tail){
if(temp.charAt(head) != temp.charAt(tail)){
return false;
}
head++;
tail--;
}
return true;
}
}1.4 代码逐行解释
第一部分：字符串转换
java
String temp = x + "";
int len = temp.length();| 代码 | 作用 | 示例 |
|---|---|---|
x + "" |
将整数转换为字符串 | 121 → "121" |
temp.length() |
获取字符串长度 | "121" → 3 |
第二部分：双指针初始化
java
int head = 0; // 头指针，指向字符串开头
int tail = len - 1; // 尾指针，指向字符串末尾指针位置示意图：
字符串: "1 2 1"
索引: 0 1 2
↑ ↑
head tail第三部分：循环比较
java
while(head < tail){
if(temp.charAt(head) != temp.charAt(tail)){
return false;
}
head++;
tail--;
}执行流程：
以 x = 121 为例：
初始状态：head = 0, tail = 2
第1次循环：
head(0) < tail(2) → 继续
temp.charAt(0) = '1'
temp.charAt(2) = '1'
相等，head++ → 1, tail-- → 1
第2次循环：
head(1) < tail(1) → 不满足，退出循环
返回 true以 x = -121 为例：
初始状态：head = 0, tail = 3
第1次循环：
head(0) < tail(3) → 继续
temp.charAt(0) = '-'
temp.charAt(3) = '1'
不相等，返回 false1.5 复杂度分析
| 分析维度 | 复杂度 | 说明 |
|---|---|---|
| 时间复杂度 | O(n) | n为数字的位数，最多比较 n/2 次 |
| 空间复杂度 | O(n) | 需要额外的字符串空间 |
1.6 边界情况处理
| 输入 | 说明 | 输出 |
|---|---|---|
0 |
单个数字 | true |
-1 |
负数（有符号） | false |
11 |
两位回文数 | true |
12321 |
奇数位回文 | true |
1221 |
偶数位回文 | true |
2. 加一（Plus One）
2.1 题目描述
给定一个表示大整数的整数数组 digits，其中 digits[i] 是整数的第 i 位数字。这些数字按从左到右，从最高位到最低位排列。这个大整数不包含任何前导 0。
将大整数加 1，并返回结果的数字数组。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
加 1 后得到 123 + 1 = 124。
因此，结果应该是 [1,2,4]。示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
加 1 后得到 4321 + 1 = 4322。
因此，结果应该是 [4,3,2,2]。示例 3：
输入：digits = [9]
输出：[1,0]
解释：输入数组表示数字 9。
加 1 得到了 9 + 1 = 10。
因此，结果应该是 [1,0]。2.2 解题思路
这道题的核心是将数组表示的数字转换为整数，加1后再转换回数组。
解题步骤：
- 将数组中的每个数字拼接成字符串
- 将字符串转换为整数
- 将整数加1
- 将结果转换回字符串
- 将字符串的每个字符转换为数字数组
2.3 代码实现
java
class Solution {
public int[] plusOne(int[] digits) {
int len = digits.length;
String temp = "";
// 步骤1：将数组转换为字符串
for(int i = 0; i < len; i++){
temp += digits[i];
}
// 步骤2：转换为整数并加1
int number = Integer.parseInt(temp);
number++;
// 步骤3：转换回字符串
temp = number + "";
// 步骤4：转换为数字数组
int[] digits2 = new int[temp.length()];
for(int i = 0; i < temp.length(); i++){
digits2[i] = temp.charAt(i) - '0';
}
return digits2;
}
}2.4 代码逐行解释
第一部分：数组转字符串
java
int len = digits.length;
String temp = "";
for(int i = 0; i < len; i++){
temp += digits[i];
}执行示例：
输入 digits = [1,2,3]：
i = 0: temp = "" + 1 = "1"
i = 1: temp = "1" + 2 = "12"
i = 2: temp = "12" + 3 = "123"
结果：temp = "123"第二部分：字符串转整数并加1
java
int number = Integer.parseInt(temp);
number++;| 字符串 | 转换后整数 | 加1后 |
|---|---|---|
"123" |
123 |
124 |
"4321" |
4321 |
4322 |
"9" |
9 |
10 |
第三部分：整数转字符串再转数组
java
temp = number + "";
int[] digits2 = new int[temp.length()];
for(int i = 0; i < temp.length(); i++){
digits2[i] = temp.charAt(i) - '0';
}字符转数字原理：
java
temp.charAt(i) - '0'| 字符 | ASCII值 | 减去'0'后 | 结果 |
|---|---|---|---|
'1' |
49 | 49 - 48 | 1 |
'2' |
50 | 50 - 48 | 2 |
'3' |
51 | 51 - 48 | 3 |
执行示例：
number = 124：
temp = "124"
digits2 = new int[3]
i = 0: digits2[0] = '1' - '0' = 1
i = 1: digits2[1] = '2' - '0' = 2
i = 2: digits2[2] = '4' - '0' = 4
结果：[1, 2, 4]2.5 完整执行流程示例
示例1 ：digits = [1,2,3]
步骤1：temp = "123"
步骤2：number = 123, number++ → 124
步骤3：temp = "124"
步骤4：digits2 = [1, 2, 4]
输出：[1, 2, 4]示例2 ：digits = [9]
步骤1：temp = "9"
步骤2：number = 9, number++ → 10
步骤3：temp = "10"
步骤4：digits2 = [1, 0]
输出：[1, 0]示例3 ：digits = [4,3,2,1]
步骤1：temp = "4321"
步骤2：number = 4321, number++ → 4322
步骤3：temp = "4322"
步骤4：digits2 = [4, 3, 2, 2]
输出：[4, 3, 2, 2]2.6 复杂度分析
| 分析维度 | 复杂度 | 说明 |
|---|---|---|
| 时间复杂度 | O(n) | 遍历数组两次（转字符串和转数组） |
| 空间复杂度 | O(n) | 需要额外的字符串和数组空间 |
2.7 注意事项
重要提示：
这种解法通过字符串和整数转换来处理大整数，适用于LeetCode的测试用例。但在实际应用中，如果数字很大（超过int范围），需要使用long类型或其他大整数处理方法。
Java中int的范围：-2³¹ 到 2³¹-1（约-21亿到21亿）
3. 两题对比与总结
3.1 共同点
| 对比项 | 回文数 | 加一 |
|---|---|---|
| 数字类型 | 整数 | 整数数组 |
| 转换方式 | 整数转字符串 | 数组 ↔ 字符串 ↔ 整数 |
| 核心技巧 | 双指针比较 | 字符串拼接 |
| 边界处理 | 负数自动处理 | 自动处理进位 |
3.2 字符串操作技巧总结
整数转字符串：
java
// 方法1：拼接空字符串
String str = x + "";
// 方法2：valueOf方法
String str = String.valueOf(x);
// 方法3：toString方法
String str = Integer.toString(x);字符串转整数：
java
int num = Integer.parseInt(str);字符转数字：
java
char c = '5';
int num = c - '0'; // 结果为5数字转字符：
java
int num = 5;
char c = (char)(num + '0'); // 结果为'5'3.3 双指针算法模板
java
// 双指针模板
int left = 0;
int right = length - 1;
while(left < right){
// 处理逻辑
if(某个条件){
return 某个值;
}
left++;
right--;
}
return 默认值;4. 总结
今天我们学习了两道基础题目：
- 回文数：掌握双指针判断回文的方法，理解数字与字符串的转换
- 加一：通过字符串和整数的转换实现大整数加法，理解字符与数字的转换
核心收获：
- 数字转字符串是处理数字问题的有效方法
- 双指针是判断回文等对称问题的标准算法
- 字符操作是算法面试中的常见考点
- 字符串拼接和转换是Java编程的基础技能
练习建议：
- 尝试不将整数转为字符串，直接反转数字来判断回文
- 思考如果数组表示的数字非常大（超出int范围），如何处理加一问题
- 尝试从后向前处理数组，直接在原数组上操作
参考资源
文章标签
#LeetCode #算法 #Java #字符串 #数组
喜欢这篇文章吗？别忘了点赞、收藏和分享！你的支持是我创作的最大动力！