[PTA]最长连续递增子序列

给定一个顺序存储的线性表，请设计一个算法查找该线性表中最长的连续递增子序列。例如，(1,9,2,5,7,3,4,6,8,0)中最长的递增子序列为(3,4,6,8)。

输入格式:

输入第1行给出正整数n（≤105）；第2行给出n个整数，其间以空格分隔。

输出格式:

在一行中输出第一次出现的最长连续递增子序列，数字之间用空格分隔，序列结尾不能有多余空格。

输入样例：

15
1 9 2 5 7 3 4 6 8 0 11 15 17 17 10

输出样例：

3 4 6 8

代码长度限制                                                                                                                  16 KB

时间限制                                                                                                                        400 ms

内存限制                                                                                                                         64 MB

思路1 ：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100005
typedef struct
{
    int* Data;
    int lenth;
}list;

int main()
{
    int lenth;  scanf("%d", &lenth);
    list* L = (list*)malloc(sizeof(list)); L->lenth = lenth;
    L->Data = (int*)malloc(sizeof(int) * lenth);
    int i = 0;
    for (; i < lenth; i++) scanf("%d", &L->Data[i]);
    int temp, left = 0, right = 0;
    _Bool iw = 0;
    for (i = 1; i < lenth; i++) {
        if (L->Data[i] > L->Data[i - 1] && !iw) {
            temp = i - 1;
            iw = 1;
        }
        else if (L->Data[i] <= L->Data[i - 1] && iw) {
            if (i - 1 - temp > right - left) {
                right = i - 1;
                left = temp;
            }
            iw = 0;
        }
        else if (iw && i == lenth - 1)
            if (i - 1 - temp > right - left) {
                right = i;
                left = temp;
            }
    }

    printf("%d", L->Data[left]);
    for (i = left + 1; i <= right; i++) printf(" %d", L->Data[i]);
    puts("");
    free(L->Data);
    free(L);
}

用 left 和 right 记录最长递增数列的左右端，初始化都指向0。用 iw 来记录数列状态， 初始化为0，递增数列（L->Data[i] > L->Data[i - 1]）则 iw=1 ，非递增数列 iw=0。

递增数列且 iw ==0 ，说明在这之前，都是非递增的，也就是此时在某个递增数列的开头，用 temp 记录下 i-1 这个左端，同时 iw =1。由于 iw=1，因而当前这个递增数列之后的元素都进不来这个if（），不会影响 temp 的记录。

直到数列停止递增，进入else if（），i-1这时就是右端，i-1-temp ,能够得到刚遍历的递增数列的长，和 right - left 比较，并将较长的（最长的）递增数列的左右端分别保存在 left 和 right，同时 iw =0。

因为只关注数列状态的变化，如果最长的递增数列一直持续到数组末尾，就没有状态的变化，那么这个数列很有可能就不会被记录，因而在数组末尾，如果 iw==1 ，就要去比较了，而且对于这个数列，right 如果要更新，更新为 i 而不是 i-1。

  

思路2：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100005
typedef struct
{
    int* Data;
    int lenth;
}list;

int main()
{
    int n;  scanf("%d", &n);
    list* L = (list*)malloc(sizeof(list));
    L->lenth = n, L->Data = (int*)malloc(sizeof(int) * n);
    int i;
    for (i = 0; i < n; i++) scanf("%d", &L->Data[i]);
    int index = 0, tmplen = 1, maxlen = 1;
    for (i = 1; i < n; i++) {
        if (L->Data[i] > L->Data[i - 1]) {
            if (++tmplen > maxlen) {
                index = i;
                maxlen = tmplen;
            }
        }
        else tmplen = 1;
    }

    for (i = index - maxlen + 1; i < index; i++) printf("%d ", L->Data[i]);
    printf("%d\n", L->Data[i]);

    free(L->Data);
    free(L);
    return 0;
}

从下标1开始遍历，比较 i 和 i-1 ， 用 tmplen 随时记录递增数列的长度，初始化为1，递增数列（L->Data[i] > L->Data[i - 1]）则 tmplen++ ，非递增数列 tmplen 重置为1，然后立即比较 maxlen 和 tmplen，用 maxlen 记录较大的（最大的）递增数列长，用 index 记录记录较大的（最大的）递增数列的最后一个元素。

算法2可能有改进的空间，尤其在每一次 tmplen 更新都伴随着 maxlen 和 index 的比较、更新这点。 

两种方法的时间复杂度大概都是O(n)。 

 如有误还望指正。