题目：加一
“
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
“
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：
输入：digits = [0]
输出：[1]
思路
遍历数组：从最后一位开始加一，如果该位加完小于 10，则返回数组，因为不需要进位。
处理进位：如果加完后一位等于 10，将其置为 0，继续处理下一位。
最高位进位：如果所有的位都进位完毕，最后需要在数组的前面加一个 1。
golang 实现
package main

import “fmt”

func plusOne(digits []int) []int {
// 从数组末尾开始处理加1操作
for i := len(digits) – 1; i >= 0; i– {
digits[i]++ // 当前位加1
if digits[i] < 10 {
return digits // 如果没有进位，直接返回结果
}
digits[i] = 0 // 如果进位，需要将当前位设为0
}
return append([]int{1}, digits…)
}

func main() {
// 测试用例
fmt.Println(plusOne([]int{1, 2, 3})) // 输出: [1, 2, 4]
fmt.Println(plusOne([]int{4, 3, 2, 1})) // 输出: [4, 3, 2, 2]
fmt.Println(plusOne([]int{9, 9, 9})) // 输出: [1, 0, 0, 0]
fmt.Println(plusOne([]int{0})) // 输出: [1]
}

Java 实现
import java.util.Arrays;

public class PlusOne {
public static int[] plusOne(int[] digits) {
// 从数组末尾开始处理加1操作
for (int i = digits.length – 1; i >= 0; i–) {
digits[i]++;
if (digits[i] < 10) {
return digits; // 没有进位，直接返回
}
digits[i] = 0; // 处理进位
}
// 处理最高位进位的情况
int[] newDigits = new int[digits.length + 1];
newDigits[0] = 1;
return newDigits;
}

public static void main(String[] args) {
    System.out.println(Arrays.toString(plusOne(new int[]{1, 2, 3})));    // 输出: [1, 2, 4]
    System.out.println(Arrays.toString(plusOne(new int[]{4, 3, 2, 1}))); // 输出: [4, 3, 2, 2]
    System.out.println(Arrays.toString(plusOne(new int[]{9, 9, 9})));    // 输出: [1, 0, 0, 0]
    System.out.println(Arrays.toString(plusOne(new int[]{0})));          // 输出: [1]
}

}
C++ 实现

include

include

std::vector plusOne(std::vector& digits) {
// 从数组末尾开始处理加1操作
for (int i = digits.size() – 1; i >= 0; i–) {
digits[i]++;
if (digits[i] < 10) {
return digits; // 没有进位，直接返回
}
digits[i] = 0; // 处理进位
}
// 处理最高位进位的情况
digits.insert(digits.begin(), 1);
return digits;
}

int main() {
std::vector digits1 = {1, 2, 3};
std::vector digits2 = {4, 3, 2, 1};
std::vector digits3 = {9, 9, 9};
std::vector digits4 = {0};

for (int digit : plusOne(digits1)) {
    std::cout << digit << " "; // 输出: 1 2 4
}
std::cout << std::endl;

for (int digit : plusOne(digits2)) {
    std::cout << digit << " "; // 输出: 4 3 2 2
}
std::cout << std::endl;

for (int digit : plusOne(digits3)) {
    std::cout << digit << " "; // 输出: 1 0 0 0
}
std::cout << std::endl;

for (int digit : plusOne(digits4)) {
    std::cout << digit << " "; // 输出: 1
}
std::cout << std::endl;

}
PHP 实现
= 0; $i–) {
$digits[$i]++;
if ($digits[$i] < 10) {
return $digits; // 没有进位，直接返回
}
$digits[$i] = 0; // 处理进位
}
// 处理最高位进位的情况
array_unshift($digits, 1);
return $digits;
}

// 测试用例
print_r(plusOne([1, 2, 3])); // 输出: [1, 2, 4]
print_r(plusOne([4, 3, 2, 1])); // 输出: [4, 3, 2, 2]
print_r(plusOne([9, 9, 9])); // 输出: [1, 0, 0, 0]
print_r(plusOne([0])); // 输出: [1]
?>
代码讲解
遍历数组：
从数组的最后一位开始，将当前位加 1，如果没有进位（即加 1 后小于 10），直接返回结果。
如果有进位（即加 1 后等于 10），将该位置为 0，并继续向前进位处理。
处理最高位的进位：
如果遍历结束后数组的最高位仍然有进位，需要在数组的开头插入一个 1，表示最高位进位。