Java递归实现：判断相邻数组元素和是否为10的倍数

public static boolean divideByTen(int arr[], int num) {
    int i = num - 1; // i 代表当前要检查的元素索引（从右向左）

    if (i > 0) { // 确保有前一个元素可以组成一对
        // 错误点1：丢弃递归调用的返回值
        divideByTen(arr, num - 1); // 递归调用，但其结果被忽略了

        // 错误点2：运算符优先级问题
        if (arr[i] + arr[i - 1] % 10 == 0) // 实际是 arr[i] + (arr[i-1] % 10)
            return true;
    }
    return false; // 如果不满足条件或到达基本情况，总是返回 false
}

public class ArrayRecursion {

    /**
     * 递归判断数组中是否存在相邻元素和为10的倍数。
     * 从数组末尾（通过 index 参数指定）向前检查相邻对。
     *
     * @param arr   待检查的整数数组。
     * @param index 当前检查的数组索引。初始调用时，应传入 arr.length - 1。
     *              这个索引 arr[index] 将与 arr[index-1] 组成一对进行检查。
     * @return 如果存在相邻元素和为10的倍数，则返回 true；否则返回 false。
     */
    public static boolean checkAdjacentSumDivisibleByTen(int[] arr, int index) {
        // 基本情况1：如果索引小于1，说明没有足够的元素形成相邻对（至少需要两个元素），
        // 或者已经检查完所有可能的对，但未找到符合条件的。
        // 例如，对于空数组或只有一个元素的数组，index 初始值会是 -1 或 0，
        // 在这种情况下直接返回 false。
        if (index < 1) {
            return false;
        }

        // 递归步骤：
        // 1. 检查当前索引 arr[index] 及其前一个索引 arr[index - 1] 的元素和是否为10的倍数。
        //    注意：使用括号确保先求和再取模，避免运算符优先级问题。
        if ((arr[index] + arr[index - 1]) % 10 == 0) {
            return true; // 找到符合条件的对，立即返回 true，停止进一步递归。
        }

        // 2. 如果当前对不符合条件，则递归调用自身，检查数组中前一个位置的相邻对。
        //    关键：必须返回递归调用的结果，将子问题的结果传递回父级调用。
        return checkAdjacentSumDivisibleByTen(arr, index - 1);
    }

    // 主方法用于测试
    public static void main(String[] args) {
        int[] arr1 = {1, 9, 2, 8, 3, 7};   // (1+9)%10=0
        int[] arr2 = {5, 5, 10, 0, 2, 3}; // (5+5)%10=0, (10+0)%10=0
        int[] arr3 = {1, 2, 3, 4, 5};     // None
        int[] arr4 = {10, 20};            // (10+20)%10=0
        int[] arr5 = {};                  // Empty array
        int[] arr6 = {7};                 // Single element array

        System.out.println("arr1: " + checkAdjacentSumDivisibleByTen(arr1, arr1.length - 1)); // 预期: true
        System.out.println("arr2: " + checkAdjacentSumDivisibleByTen(arr2, arr2.length - 1)); // 预期: true
        System.out.println("arr3: " + checkAdjacentSumDivisibleByTen(arr3, arr3.length - 1)); // 预期: false
        System.out.println("arr4: " + checkAdjacentSumDivisibleByTen(arr4, arr4.length - 1)); // 预期: true
        // 对于空数组或单元素数组，arr.length - 1 会是 -1 或 0，
        // 此时 index < 1 的基本情况会立即返回 false。
        System.out.println("arr5 (空数组): " + checkAdjacentSumDivisibleByTen(arr5, arr5.length - 1)); // 预期: false
        System.out.println("arr6 (单元素数组): " + checkAdjacentSumDivisibleByTen(arr6, arr6.length - 1)); // 预期: false
    }
}