leetcode算法题每日一练-最长湍流子数组

题目

当 A 的子数组 A[i], A[i+1], …, A[j] 满足下列条件时，我们称其为湍流子数组：

• 若 i <= k < j，当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；
• 或 若 i <= k < j，当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。

也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。

返回 A 的最大湍流子数组的长度。

示例 1：

输入：[9,4,2,10,7,8,8,1,9]
输出：5
解释：(A[1] > A[2] < A[3] > A[4] < A[5])

示例 2：

输入：[4,8,12,16]
输出：2

示例 3：

输入：[100]
输出：1

提示：

• 1 <= A.length <= 40000
• 0 <= A[i] <= 10^9

分析

可能题意有些难以理解，笔者刚看题目的时候也一头雾水，然后观察思考了一阵明白题意。根据示例一 观察可得

输入：[9,4,2,10,7,8,8,1,9]
输出：5
解释：(A[1] > A[2] < A[3] > A[4] < A[5])

发现所谓的湍流子数组就是相邻数之间的比较符号做取反，如示例一。A[1] > A[2],若作为湍流子数组的话，下个比较符号就是小于号，即 A[2]<A[3]，然后再变更比较符号，A[3]>A[4]，观察到规律后解题思路就明确了。

1. 对数组进行遍历
2. 判断当前i下标的所在数和i+1的值进行判断
3. a[i] > a[i+1],下次判断就是a[i] < a[i+1]
4. 同理，若a[i] < a[i+1],下次判断即为a[i]>a[i+1]
5. 因为是求最长湍流子数组，所以需要临时变量记录数组长度。
6. 对于a[i]=a[i+1]的情况，不符合湍流子数组定义，所以需要单独处理。
7. 根据示例三可得数组不为空的情况下，最小湍流子数组长度为1.

实现

public static int maxTurbulenceSize(int[] arr) {

        /** 记录临时子数组长度，数组不为空的话最小长度为1 */
        int length = 1;
        /** 记录最大子数组长度 */
        int max = 0;
        /** 用来标志下次比较判断 */
        boolean flag = true;
        // 遍历数组，设置阈值为arr.length-1 防止i+1下标越界
        for (int i = 0; i < arr.length-1; i++) {
            // 判断下次比较走哪个分支
            if (flag){
                // true 走a[i] > a[i+1]的条件判断，临时子数组长度++，修改flag为false。
                // 根据湍流子数组，下次条件判断应为a[i]<a[i+1]
                if (arr[i] > arr[i +1]){
                    length++;
                    flag = false;
                    // a[i] < a[i+1]的话，那下次判断应该为a[i] > a[i+1],同时更新最大子数组。
                    // 因为a[i] > a[i+1]，占据数组两个元素所以length长度为2
                }else if (arr[i] < arr[i +1]){
                    max = Math.max(max, length);
                    length = 2;
                    flag = true;
                }else {
                    // a[i] = a[i+1]的情况，不符合定义，所以子数组长度回归最小值
                    max = Math.max(max, length);
                    length = 1;
                }
            }else {
                // false 走a[i] < a[i+1]的条件判断，临时子数组长度++，修改flag为true。
                // 根据湍流子数组，下次条件判断应为a[i]>a[i+1]
                if (arr[i] < arr[i +1]){
                    length++;
                    flag = true;
                    // a[i] > a[i+1]的话，那下次判断应该为a[i] < a[i+1],同时更新最大子数组。
                    // 因为a[i] < a[i+1]，占据数组两个元素所以length长度为2
                } else if (arr[i] > arr[i +1]){
                    max = Math.max(max, length);
                    length = 2;
                    flag = false;
                }else {
                    // a[i] = a[i+1]的情况，不符合定义，所以子数组长度回归最小值
                    max = Math.max(max, length);
                    length = 1;
                }
            }
        }
        // 最后一次比较获取最大值，比如数组长度为1的情况下。
        max = Math.max(max, length);
        return max;
    }

总结

因为只用了一次循环，所以时间复杂度额为O(n),只定义了两个临时变量，所以空间复杂度为O(2)。
当然解法不止一种，还可进行动态规划，双指标法，可以详见官方解答。