Question

我正在尝试编写一个递归函数，该函数通过指针及其大小获取数组，并返回数组中相同相邻数字的最长系列的长度（假设有一个系列），

例如：

array: {1 2 3 3 4 5 6 6 6 6 7 8} 
returns-->: 4

但我不知道我的功能有什么问题;我想我错了。

关于如何修复它的任何想法？

#include <stdio.h>
#include <stdlib.h>

int LongestSeries(int* arr, int size, int* count, int* maxcount);


int main()
{
    int i, size, *arr, count=0, maxcount=0;

    // allocation an array (unknow size)
    {
        printf("Enter Size of the Array-->:");
        scanf("%d", &size);

        arr = (int*)malloc(size * sizeof(int));
        if (arr == NULL)
        {
            printf("Error!!");
            exit(1);
        }
        printf("Enter Numbers for the Array:\n");
        for (i = 0; i < size; i++)
        {
            printf("Enter a Number-->:");
            scanf("%d", &arr[i]);
        }
    }
    for (i = 0; i < size; i++)
        printf(" %d ", arr[i]);
    printf("\n");

    printf(" %d \n", LongestSeries(arr, size, count, maxcount));

    free(arr);
    return 0;
}


int LongestSeries(int* arr, int size, int* count, int* maxcount)
{
    if (arr[size-1] == arr[size-2])
        count++;
    if (maxcount<count)
        maxcount = count;

    LongestSeries(arr, size - 1, count, maxcount);

    if (*arr==arr[0])
        return maxcount;
}

Answer 1

您的代码中存在一些问题：

1 - 函数LongestSeries期望count和maxcount参数上的指针，但您传递了变量的值。您需要更改函数调用以发送地址引用，如下所示：printf(" %d \n", LongestSeries(arr, size, &count, &maxcount));

2 - 递归终止条件位于递归调用之下，导致递归永不结束。您需要将它放在递归调用之上，最好是递归函数中的第一个语句。

3 - 由于您的count和maxcount参数是指针，因此您必须使用取消引用运算符来处理值而不是其地址：

来自：

if (arr[size-1] == arr[size-2])
        count++;
    if (maxcount<count)
        maxcount = count;

到此：

if (arr[size-1] == arr[size-2])
        ++*count;
    if (*maxcount < *count)
        *maxcount = *count;

4 - 这同样适用于你的return语句：你正在撤回指针，但你的函数需要返回一个int，所以：

来自：

if (*arr==arr[0])
        return maxcount;

到此：

if (*arr==arr[0])
        return *maxcount;

5 - 由于您需要最长的系列，因此count变量需要从1开始，而不是0，因为数字序列中可能的最低序列是1，而不是0

希望它有所帮助。

Answer 2

@MarcLaurent指出，发布的代码存在许多问题。但从根本上说，这种方法似乎存在缺陷。编写递归函数的关键不是让事情变得困难，而是为了简化事情。有助于递归的问题可以分解为更小的子问题。

对于手头的问题，找到数组中最长重复数字序列的长度，一个递归方法将确认该长度是重复数字的初始序列的长度，或最长序列的长度在数组的其余部分重复数字。在代码中，这可能如下所示：

size_t longest_seq(size_t sz, int *a)
{
    if (sz == 0) {
        return 0;
    }
    size_t count = init_seq(sz, a);
    return MAX(count, longest_seq(sz - count, a + count));
}

这里，如果数组不包含任何元素（基本情况），则返回0。否则，返回初始序列的较大长度或数组其余部分中的最长序列。 MAX这里是一个宏，很容易定义，我们只需编写一个函数来查找初始序列的长度。这也可以是递归的，但不一定是。

查找初始序列长度的递归函数可能如下所示：

size_t init_seq(size_t sz, int *a)
{
    if (sz == 0) {
        return 0;
    }
    return 1 + ((sz > 1 && a[0] == a[1]) ? init_seq(sz - 1, a + 1) : 0);
}

这里，如果数组不包含任何元素（基本情况），那么长度显然是0，否则返回值是1添加到剩余部分的初始序列的长度数组（如果有下一个元素，并且该元素与第一个元素相同）或0。

通过这种方式解决问题，解决方案简单易懂。以下是实施上述想法的完整计划：

#include <stdio.h>

#define MAX(X, Y) (X) > (Y) ? (X) : (Y)

size_t longest_seq(size_t, int *);
size_t init_seq(size_t, int *);

int main(void)
{
    size_t arr_sz;
    printf("Enter number of elements: ");
    scanf("%zu", &arr_sz);

    int arr[arr_sz];

    printf("Enter array values:\n");
    for (size_t i = 0; i < arr_sz; i++) {
        scanf("%d", &arr[i]);
    }

    printf("Longest sequence of repeats: %zu\n", longest_seq(arr_sz, arr));

    return 0;
}

size_t longest_seq(size_t sz, int *a)
{
    if (sz == 0) {
        return 0;
    }
    size_t count = init_seq(sz, a);
    return MAX(count, longest_seq(sz - count, a + count));
}

size_t init_seq(size_t sz, int *a)
{
    if (sz == 0) {
        return 0;
    }
    return 1 + ((sz > 1 && a[0] == a[1]) ? init_seq(sz - 1, a + 1) : 0);
}

示例程序交互：

Enter number of elements: 12
Enter array values:
1 2 3 3 4 5 6 6 6 6 7 8
Longest sequence of repeats: 4

Answer 3

int LongestSeries(int* arr, int size, int count, int maxcount){
    if(size == 0)
        return maxcount < count ? count : maxcount;

    if(count == 0){
        return LongestSeries(arr + 1, size - 1, 1, maxcount);
    } else {
        if(arr[-1] == *arr){
            return LongestSeries(arr + 1, size - 1, count + 1, maxcount);
        } else {
            if(count > maxcount)
                maxcount = count;
            return LongestSeries(arr + 1, size - 1, 1, maxcount);
        }
    }
}

int main(void){
    int arr[] = {1, 2, 3, 3, 4, 5, 6, 6, 6, 6, 7, 8};
    int size = sizeof(arr)/sizeof(*arr);
    printf("%d\n", LongestSeries(arr, size, 0, 0));
}

减少代码：

int LongestSeries(int* arr, int size, int count, int maxcount){
    if(size == 0)
        return maxcount < count ? count : maxcount;

    if(count == 0 || arr[-1] != *arr){
        if(count > maxcount)
            maxcount = count;
        return LongestSeries(arr + 1, size - 1, 1, maxcount);
    }
    return LongestSeries(arr + 1, size - 1, count + 1, maxcount);
}

查找带递归的系列

3 个答案: