高效检查数组奇偶交替模式：JavaScript实现与解析

问题描述

在处理数组数据时，有时需要验证其元素是否按照特定的模式排列。一个常见的模式是“奇偶交替”，即数组中的数字应严格遵循奇数-偶数-奇数...或偶数-奇数-偶数...的顺序。如果数组中存在任何数字打破了这种交替模式，我们需要返回该数字的索引；如果整个数组都符合模式，则返回 -1。数组中的所有数字均为正整数。

例如：

• [1, 4, 5, 7, 4]：在索引 3 处，7 (奇数) 后面跟着 4 (偶数)，但它前面是 5 (奇数)。模式是 奇-偶-奇-奇-偶，在索引 3 7（奇数）和 5（奇数）之间出现 奇-奇 模式中断。应返回 3。
• [25, 25, 25]：在索引 1 处，25 (奇数) 后面跟着 25 (奇数)。模式中断。应返回 1。
• [4, 5, 2, 7, 4, 9]：所有数字都严格交替 偶-奇-偶-奇-偶-奇。应返回 -1。

解决方案的核心思路

解决此类问题的关键在于简化判断逻辑。我们不需要预先判断数组是从奇数开始还是从偶数开始，也不需要将偶数索引和奇数索引的元素分开处理。一个更直接且高效的方法是：从第二个元素开始，将当前元素的奇偶性与其前一个元素的奇偶性进行比较。

如果当前元素的奇偶性与前一个元素的奇偶性相同，则意味着模式被打破，因为按照交替模式，它们的奇偶性应该不同。此时，我们立即返回当前元素的索引。如果遍历完整个数组都没有发现这种模式中断，则表示数组完全符合交替模式，返回 -1。

JavaScript 实现

基于上述核心思路，我们可以编写一个简洁高效的 JavaScript 函数：

立即学习“Java免费学习笔记（深入）”；

/**
 * 检查数组是否遵循奇偶交替模式。
 * 如果发现模式中断，返回第一个中断点的索引。
 * 如果整个数组都遵循模式，返回 -1。
 *
 * @param {number[]} arr - 待检查的数字数组，所有数字均为正整数。
 * @returns {number} - 模式中断的索引，或 -1。
 */
function checkAlternatingParity(arr) {
  // 用于存储前一个元素的奇偶性。
  // 注意：对于第一个元素，x将是undefined，第一次比较x === y会是false，
  // 随后x会被正确初始化为第一个元素的奇偶性。
  let previousParity;

  for (let i = 0; i < arr.length; i++) {
    // 计算当前元素的奇偶性 (0 表示偶数，1 表示奇数)
    const currentParity = arr[i] % 2;

    // 从第二个元素开始（即 i > 0），
    // 检查当前元素的奇偶性是否与前一个元素的奇偶性相同。
    // 如果相同，则模式被打破。
    if (i > 0 && previousParity === currentParity) {
      return i; // 返回当前元素的索引
    }

    // 更新 previousParity 为当前元素的奇偶性，供下一个迭代使用。
    previousParity = currentParity;
  }

  // 如果循环结束，表示没有发现模式中断，返回 -1。
  return -1;
}

// 示例测试
console.log(checkAlternatingParity([1, 4, 5, 7, 4]));     // 预期输出: 3
console.log(checkAlternatingParity([25, 25, 25]));       // 预期输出: 1
console.log(checkAlternatingParity([4, 5, 2, 7, 4, 9])); // 预期输出: -1
console.log(checkAlternatingParity([]));                 // 预期输出: -1 (空数组视为符合模式)
console.log(checkAlternatingParity([1]));                // 预期输出: -1 (单元素数组视为符合模式)

代码解析

1. previousParity 变量：

   • let previousParity;：这个变量用来存储前一个元素的奇偶性（0代表偶数，1代表奇数）。
   • 在循环开始时，previousParity是undefined。当i=0时，i > 0条件不满足，所以不会进行比较。previousParity随后会被赋值为arr[0] % 2。这种处理方式巧妙地避免了对第一个元素进行特殊判断。

2. 循环遍历：

   • for (let i = 0; i

3. 计算当前奇偶性：

   • const currentParity = arr[i] % 2;：使用模运算符 % 来获取当前数字的奇偶性。如果结果是 0，则为偶数；如果结果是 1，则为奇数。

4. 模式检查：

   • if (i > 0 && previousParity === currentParity)：这是核心判断逻辑。
     • i > 0：确保我们从第二个元素开始进行比较，因为第一个元素没有“前一个”元素来比较。
     • previousParity === currentParity：如果当前元素的奇偶性与前一个元素的奇偶性相同，这意味着模式被打破了（例如，奇数后面跟着奇数，或者偶数后面跟着偶数）。
     • 如果条件成立，return i; 立即返回当前元素的索引，表示这是第一个模式中断点。

5. 更新 previousParity：

   

   家作

   淘宝推出的家装家居AI创意设计工具

   下载
   • previousParity = currentParity;：在每次循环的最后，将当前元素的奇偶性保存到 previousParity 中，以便在下一个迭代中作为“前一个”元素的奇偶性进行比较。

6. 无中断情况：

   • return -1;：如果循环顺利完成，没有触发任何 return i; 语句，则表示整个数组都遵循奇偶交替模式，此时返回 -1。

示例分析

让我们通过几个例子来深入理解 checkAlternatingParity 函数的运行过程。

示例 1: [1, 4, 5, 7, 4]

在 i = 3 时，arr[3] 是 7，其奇偶性 currentParity 是 1。此时 previousParity 也是 1（来自 arr[2] 即 5）。由于 1 === 1，模式被打破，函数返回 3。

示例 2: [25, 25, 25]

在 i = 1 时，arr[1] 是 25，其奇偶性 currentParity 是 1。此时 previousParity 也是 1（来自 arr[0] 即 25）。由于 1 === 1，模式被打破，函数返回 1。

示例 3: [4, 5, 2, 7, 4, 9]

所有元素都遵循交替模式，循环结束，函数返回 -1。

注意事项与优化

• 时间复杂度： 该解决方案的时间复杂度为 O(n)，其中 n 是数组的长度。因为我们只需要遍历数组一次。
• 空间复杂度： 空间复杂度为 O(1)，因为我们只使用了几个固定大小的变量。
• 空数组和单元素数组：
  • 对于空数组 []，循环不会执行，函数直接返回 -1，这符合预期（空数组没有模式可打破）。
  • 对于单元素数组 [X]，循环只执行一次（i=0），i > 0 条件不满足，previousParity 被赋值，然后循环结束。函数返回 -1，这也符合预期（单元素数组没有相邻元素来打破模式）。
• 数据类型： 题目明确指出所有数字都是正整数。如果数组可能包含负数、零或非整数，则需要调整奇偶性判断逻辑（例如，Math.abs(num) % 2 或更复杂的类型检查）。
• 模运算符的性质： num % 2 对于正整数能正确返回 0 或 1。

总结

通过比较相邻元素的奇偶性，我们能够以线性时间复杂度 O(n) 和常数空间复杂度 O(1) 高效地检查数组是否遵循奇偶交替模式。这种方法不仅代码简洁，而且逻辑清晰，能够准确地定位第一个模式中断点，并优雅地处理各种边界情况，是解决此类问题的理想方案。