AI刷题判断数组是否单调|豆包MarsCode AI刷题

问题解析

我们需要判断一个数组是否为单调数组。一个数组是单调的当且仅当它是单调递增或单调递减的。

• 单调递增：对于数组中的任意两个元素 nums[i] 和 nums[j]（其中 i <= j），有 nums[i] <= nums[j]。
• 单调递减：对于数组中的任意两个元素 nums[i] 和 nums[j]（其中 i <= j），有 nums[i] >= nums[j]。

解题思路

1. 特殊情况处理：

   • 如果数组为空或长度小于等于2，则直接返回 true，因为这样的数组默认是单调的。

2. 判断数组的单调性：

   • 遍历数组，从第二个元素开始，与前一个元素进行比较。
   • 初始化一个布尔变量 increasing，用于记录当前数组是递增还是递减。
     • 如果 nums[1] >= nums[0]，则数组可能是递增的。
     • 否则，数组可能是递减的。
   • 在遍历过程中，如果发现当前元素与前一个元素的关系与预期不符，则返回 false。

3. 时间复杂度：

   • 该算法只需遍历数组一次，时间复杂度为 O(n)，其中 n 是数组的长度。

代码实现

以下是完整的 Java 代码实现：

public class Main {
    /**
     * 判断数组是否为单调数组。
     *
     * @param nums 输入的整数数组
     * @return 如果数组是单调的，返回 true；否则，返回 false
     */
    public static boolean solution(int[] nums) {
        // 如果数组为空或长度小于等于2，则默认是单调的
        if (nums == null || nums.length <= 2) {
            return true;
        }

        // 判断数组是递增还是递减
        boolean increasing = nums[1] >= nums[0];

        // 遍历数组，从第三个元素开始
        for (int i = 2; i < nums.length; i++) {
            if (increasing) {
                // 如果当前数组是递增的，但出现递减的情况，则返回 false
                if (nums[i] < nums[i - 1]) {
                    return false;
                }
            } else {
                // 如果当前数组是递减的，但出现递增的情况，则返回 false
                if (nums[i] > nums[i - 1]) {
                    return false;
                }
            }
        }

        // 如果遍历完数组都没有发现违反单调性的情况，则返回 true
        return true;
    }

    /**
     * 主函数，用于测试 solution 方法。
     *
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 测试样例 1
        int[] test1 = {1, 2, 2, 3};
        System.out.println("Test 1: " + solution(test1) + " (Expected: true)");

        // 测试样例 2
        int[] test2 = {6, 5, 4, 4};
        System.out.println("Test 2: " + solution(test2) + " (Expected: true)");

        // 测试样例 3
        int[] test3 = {1, 3, 2, 4, 5};
        System.out.println("Test 3: " + solution(test3) + " (Expected: false)");

        // 额外测试样例 4: 全部相同
        int[] test4 = {5, 5, 5, 5};
        System.out.println("Test 4: " + solution(test4) + " (Expected: true)");

        // 额外测试样例 5: 单调递增
        int[] test5 = {1, 2, 3, 4, 5};
        System.out.println("Test 5: " + solution(test5) + " (Expected: true)");

        // 额外测试样例 6: 单调递减
        int[] test6 = {5, 4, 3, 2, 1};
        System.out.println("Test 6: " + solution(test6) + " (Expected: true)");
    }
}

代码说明

1. solution 方法：

   • 首先检查数组是否为 null 或长度小于等于2。如果是，则返回 true。
   • 使用 increasing 变量记录数组的当前趋势（递增或递减）。
   • 遍历数组，从第三个元素开始，检查每个元素是否与前一个元素保持相同的趋势。
   • 如果发现趋势不一致，则返回 false。
   • 如果遍历完数组都没有发现趋势不一致的情况，则返回 true。

2. main 方法：

   • 提供了三个测试样例以及三个额外的测试样例来验证 solution 方法的正确性。
   • 每个测试样例都会输出结果以及期望的输出，便于验证。

运行结果

Test 1: true (Expected: true)
Test 2: true (Expected: true)
Test 3: false (Expected: false)
Test 4: true (Expected: true)
Test 5: true (Expected: true)
Test 6: true (Expected: true)

总结

该算法通过一次遍历即可判断数组是否为单调数组，时间复杂度为 O(n)，空间复杂度为 O(1)。代码实现简洁且易于理解，适用于大多数编程场景。