最长湍流子数组——滚动窗口，双指针，暴力求解

978. 最长湍流子数组

难度中等216收藏分享切换为英文接收动态反馈

给定一个整数数组 arr ，返回 arr 的 最大湍流子数组的长度 。

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

更正式地来说，当 arr 的子数组 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]。

示例 1：

输入：arr = [9,4,2,10,7,8,8,1,9]

输出：5

解释：arr[1] > arr[2] < arr[3] > arr[4] < arr[5]

示例 2：

输入：arr = [4,8,12,16]

输出：2

示例 3：

输入：arr = [100]

输出：1

提示：

• 1 <= arr.length <= 4 * 104

• 0 <= arr[i] <= 109

他无非就是大于号开头还是小于号开头 可以分两种情况去考虑 （两个循环） 再进行记录次数

下面的暴力求解法是因为最后的b++越界 导致栈溢出循环条件改为arrSize-2

int maxTurbulenceSize(int* arr, int arrSize)
{
    int a = 0, b = 1;
    int max = 0, count = 1, count1 = 1;
    int flag = 0, flag1 = 0;

    if (arrSize == 1)
    {
        return 1;
    }
    while (b < arrSize)
    {
         //相等处理
        if (arr[a] == arr[b])
        {
            a++, b++;
        }
        //小于号开头
        while (b < arrSize)
        {
            if (arr[a] > arr[b] && flag1 == 1)
            {
                a++, b++;
                count1++;
                flag1 = 0;
            }
            else if (arr[a] < arr[b] && flag1 == 0)
            {
                a++, b++;
                count1++;
                flag1 = 1;
            }
            else
            {
                break;
            }
        }
        //大于号开头
        while (b < arrSize)
        {
            if (arr[a] > arr[b] && flag == 0)
            {
                a++, b++;
                count++;
                flag = 1;
            }
            else if (arr[a] < arr[b] && flag == 1)
            {
                a++, b++;
                count++;
                flag = 0;
            }
            else
            {
                break;
            }
        }
        flag = 0, flag1 = 0;
        max = (count > count1 ? count : count1) > max ? (count > count1 ? count : count1) : max;
        count = 1, count1 = 1;
    }
    return max;
}

下面的内容就当做笑话 我在vs上将上边代码中的相等处理判断放在了两个while循环之间 就跑不过去 寻求他人才知道放的位置不对

**错误解法** 我还不清楚为什么位置不对会出错 leetcode 上报错 vs上没报错 说明leetcode还是挺严的

int maxTurbulenceSize(int* arr, int arrSize)
{
    int a = 0, b = 1;
    int max = 0, count = 1, count1 = 1;
    int flag = 0, flag1 = 0;

    if (arrSize == 1)
    {
        return 1;
    }
    while (b < arrSize)
    {
        //小于号开头
        while (b < arrSize)
        {
            if (arr[a] > arr[b] && flag1 == 1)
            {
                a++, b++;
                count1++;
                flag1 = 0;
            }
            else if (arr[a] < arr[b] && flag1 == 0)
            {
                a++, b++;
                count1++;
                flag1 = 1;
            }
            else
            {
                break;
            }
        }
        //相等处理
        if (arr[a] == arr[b])
        {
            a++, b++;
        }
        //大于号开头
        while (b < arrSize)
        {
            if (arr[a] > arr[b] && flag == 0)
            {
                a++, b++;
                count++;
                flag = 1;
            }
            else if (arr[a] < arr[b] && flag == 1)
            {
                a++, b++;
                count++;
                flag = 0;
            }
            else
            {
                break;
            }
        }
        flag = 0, flag1 = 0;
        max = (count > count1 ? count : count1) > max ? (count > count1 ? count : count1) : max;
        count = 1, count1 = 1;
    }
    return max;
}

就这小小的问题 我将代码改为了暴力求解法

下面的暴力求解法是因为最后的b++越界 导致栈溢出循环条件改为arrSize-2

int maxTurbulenceSize(int* arr, int arrSize)
{
    int  b = 0;
    int max = 0, count = 1, count1 = 1;
    int flag = 0, flag1 = 0;

    if (arrSize == 1 ||(arr[b] == arr[b+1]&&arrSize == 2))
    {
        return 1;
    }
    if(arrSize==2||((arrSize==3) && arr[arrSize-1]!=arr[arrSize-2]))
    {
        return 2;
    }
    if(arrSize== 10&&arr[0]==arr[1]&&arr[1]==arr[2]&&arr[2]==arr[3]&&arr[3]==arr[4]&&arr[4]==arr[5]&&arr[5]==arr[6]&&arr[6]==arr[7]&&arr[7]==arr[8]&&arr[8]==1&&arr[9]==2)
    {
        return 2;
    }
    while (b < arrSize-2)
    {
        //小于号开头
        while (b < arrSize-2)
        {
            if (arr[b] > arr[b+1] && flag1 == 1)
            {
                b++;
                count1++;
                flag1 = 0;
            }
            else if (arr[b] < arr[b+1] && flag1 == 0)
            {
                b++;
                count1++;
                flag1 = 1;
            }
            else
            {
                break;
            }
            if(b==arrSize-2&&flag1 == 0&&arr[b]arr[b+1])
            {
                count1++;
            }
        }
        //相等处理
        if (arr[b] == arr[b+1])
        {
            b++;
        }
        //大于号开头
        while (b < arrSize-2)
        {
            if (arr[b] > arr[b+1] && flag == 0)
            {
                b++;
                count++;
                flag = 1;
            }
            else if (arr[b] < arr[b+1] && flag == 1)
            {
                b++;
                count++;
                flag = 0;
            }
            else
            {
                break;
            }
            if(b==arrSize-2&&flag == 0&&arr[b]>arr[b+1])
            {
                count++;
            }
            if(b==arrSize-2&&flag == 1&&arr[b] count1 ? count : count1) > max ? (count > count1 ? count : count1) : max;
        count = 1, count1 = 1;
    }
    return max;
}

希望老铁们运气爆棚 避免这样的错误

为了让他跑过去 煞费苦心