针对 LeetCode 3830“移除至多一个元素后的最长交替子数组”，这里提供 JavaScript (ES6+) 实现，采用 动态规划 (O(n) 时间, O(1) 空间)，代码简洁高效。

---

核心思路

维护 4 个状态（以当前元素结尾）：

· inc0：最后一段比较为 上升 (<)，未删除元素
· dec0：最后一段比较为 下降 (>)，未删除元素
· inc1：最后一段比较为 上升，已删除一个元素
· dec1：最后一段比较为 下降，已删除一个元素

每个状态初始为 1（仅包含当前元素本身）。

转移（遍历 i 从 1 到 n-1）：

1. 正常延续（不删除 i-1）：
   · 若 nums[i] > nums[i-1]：
          inc0 = dec0_prev + 1，inc1 = dec1_prev + 1
   · 若 nums[i] < nums[i-1]：
          dec0 = inc0_prev + 1，dec1 = inc1_prev + 1
2. 删除 i-1（使用一次删除机会）：需 i >= 2，比较 nums[i] 与 nums[i-2]：
   · 若 nums[i] > nums[i-2]：inc1 = max(inc1, dec0_prev2 + 1)
   · 若 nums[i] < nums[i-2]：dec1 = max(dec1, inc0_prev2 + 1)
3. 每个状态至少为 1（重新开始）。

---

JavaScript 代码

```javascript
/**
 * @param {number[]} nums
 * @return {number}
 */
var longestAlternating = function(nums) {
    const n = nums.length;
    if (n === 0) return 0;
    
    // 初始化状态（以 nums[0] 结尾）
    let inc0 = 1, dec0 = 1, inc1 = 1, dec1 = 1;
    let ans = 1;
    
    // 保存 i-2 时的未删除状态（初始不存在，设为 0）
    let inc0_prev2 = 0, dec0_prev2 = 0;
    
    for (let i = 1; i < n; i++) {
        // 保存当前状态，作为下一轮迭代的 i-2
        const next_inc0 = inc0, next_dec0 = dec0;
        
        // 保存上一轮状态（i-1）
        const prev_inc0 = inc0, prev_dec0 = dec0;
        const prev_inc1 = inc1, prev_dec1 = dec1;
        
        // 重置当前状态（至少为 1）
        inc0 = dec0 = inc1 = dec1 = 1;
        
        // ---- 正常延续（不删除 i-1） ----
        if (nums[i] > nums[i - 1]) {
            inc0 = Math.max(inc0, prev_dec0 + 1);
            inc1 = Math.max(inc1, prev_dec1 + 1);
        } else if (nums[i] < nums[i - 1]) {
            dec0 = Math.max(dec0, prev_inc0 + 1);
            dec1 = Math.max(dec1, prev_inc1 + 1);
        }
        
        // ---- 删除 i-1（跳过中间元素） ----
        if (i >= 2) {
            if (nums[i] > nums[i - 2]) {
                inc1 = Math.max(inc1, dec0_prev2 + 1);
            } else if (nums[i] < nums[i - 2]) {
                dec1 = Math.max(dec1, inc0_prev2 + 1);
            }
        }
        
        // 更新全局最大值
        ans = Math.max(ans, inc0, dec0, inc1, dec1);
        
        // 更新 i-2 状态为旧的 i-1 状态（即本次迭代前的 inc0/dec0）
        inc0_prev2 = next_inc0;
        dec0_prev2 = next_dec0;
    }
    
    return ans;
};
```

---

复杂度分析

· 时间复杂度：O(n)，单次遍历。
· 空间复杂度：O(1)，仅使用常数个变量。

---

测试用例

```javascript
console.log(longestAlternating([1,2,3,4]));          // 2
console.log(longestAlternating([1,3,2,4]));          // 4
console.log(longestAlternating([1,2,1,3,2]));        // 5
console.log(longestAlternating([1,1,1]));            // 1
console.log(longestAlternating([1,2]));              // 2
```

---

如果需要更直观的解法，也可以使用前后缀分解，但 DP 解法空间更优。以上代码可直接提交到 LeetCode。