C 递归 function 检查两个 arrays 是否颠倒

Question

我需要检查两个 arrays 是否颠倒，例如A[3] = {1, 2, 3}和B[3] = {3, 2, 1}

如果 A 不是给定长度的 B 的反转，则返回 0，否则返回 1。

这是我现在设法做的

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int* input_array(int);
int areReversed(int*, int*, int);

int main()
{
    int n = 0;
    int* A, * B;
    printf("please enter the size of arrays: \n");
    scanf("%d", &n);
    printf("please enter elements of the first array: \n");
    A = input_array(n);
    printf("please enter elements of the second array: \n");
    B = input_array(n);
    areReversed(A, B, n) ? printf("Arrays are the opposite to one another.\n") : printf("Arrays are not the opposite to one another.\n");
    free(A); free(B);
}

int areReversed(int* A, int* B, int n) {
    int i = 0, j = n-1;
    int reverse = 0;
    if (n > 1)
    {
        for (i = 0, j = 0; i < n && j >= 0; i++, j--)
        {
            if (A[i] == B[j])
            {
                return areReversed(A + 1, B + 1, n);
            }
            if (A[i] != B[j])
                return 0;

        }
        return 1;
    }
}

int* input_array(int n) {
    int i;
    int* A = (int*)malloc(n * sizeof(int));
    assert(A);
    printf("Enter %d integers\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", A + i);
    }
    return A;
}

`

但遗憾的是它不起作用而且我已经尝试了很多东西......即使你可以给出提示它也会很棒

Answer 1

递归的关键是：

1. 拥有一个稳健的终止条件，该条件将得到满足，并且具有明确的答案。
2. 该问题是一个较小但相同问题的函数。

在这种情况下，终止条件是数组n的长度为零（返回真），或者A[0] != B[n-1] （返回假）

对于长度为n的数组，其中两端相等 ( A[0] == B[n-1] )， A可能与B相反，因此您将问题转化为一个较小的问题并进行测试。 较小的问题是每个阵列两端的“一入”——即：

areReversed( &A[1], B, n - 1 ) ;

如果您是迭代地而不是递归地执行此操作，则比较A[0]与B[n-1]之后的“较小”测试将是比较A[1]与B[n-2] 。 在递归中只测试一对，但递归调用修改参数以达到相同的效果。 所以这里递归调用的A是父调用&A[1] （或者A + 1如果你喜欢 - 我不喜欢），并且数组长度短一个所以递归调用的B[n-1]是父调用调用B[n-2] 。

所以：

#include <stdio.h>
#include <stdbool.h>

bool areReversed( int* A, int* B, int n) 
{
    int is_reverse = false ;
    if( n == 0 )
    {
        is_reverse = true ;
    }
    else if( A[0] == B[n-1] )
    {
        is_reverse = areReversed( &A[1], B, n - 1 ) ;
    }

    return is_reverse ;
}

int main()
{
    int A1[] = {1, 2, 5, 14, 9, 3} ;
    int B1[] = {3, 9, 14, 5, 2, 1} ;
    int A2[] = {1, 2, 5, 14, 9, 3} ;
    int B2[] = {3, 9, 14, 5, 2, 7} ;
    
    bool R1 = areReversed( A1, B1, sizeof(A1) / sizeof(*A1) ) ;
    bool R2 = areReversed( A2, B2, sizeof(A2) / sizeof(*A2) ) ;

    printf( "A1 %s the reverse and B1\n", R1 ? "is" : "is not" ) ;
    printf( "A2 %s the reverse and B2\n", R2 ? "is" : "is not" ) ;
}

输出：

A1 is the reverse and B1
A2 is not the reverse and B2

并用奇数个元素来演示其功能：

int A1[] = {1, 2, 5,   99, 14, 9, 3} ;
int B1[] = {3, 9, 14, 101, 5, 2, 1} ;
int A2[] = {1, 2, 5,  100, 14, 9, 3} ;
int B2[] = {3, 9, 14, 100, 5, 2, 1} ;

然后输出是：

A1 is not the reverse and B1
A2 is the reverse and B2

我建议，要理解递归，您可以使用调试器单步执行代码，单步执行每个递归调用以观察“较小的问题”和满足终止条件，单步执行以观察算法的“展开”和最终回报。 在任何情况下，您都应该学会有效地使用调试器——它是一个很好的学习工具，可以观察代码的精确行为和变量的状态，同时也是调试辅助工具。

我还建议，虽然像这样的简单函数是探索递归概念的有用方法，但它也可以使用迭代简单地实现，并且在实践中可能应该以这种方式完成。 有些问题不太适合迭代，而适合递归。 对于此类问题，我会保留递归 -二叉搜索树，例如flood-fill浮现在脑海中，尽管即使这样也不需要递归，只是更简单。

递归的问题在于它具有不确定的调用堆栈要求，并且调用堆栈是一种有限的资源——你可以从字面上得到一个 _stack-overflow。 在您的测试用例中，数据在运行时提供且长度不受限制，恶意或粗心的用户可能会导致堆栈溢出，而您的代码无法防止此类攻击或滥用。

Answer 2

areReversed可以很简单：

int areReversed(int *A, int *B, int n) 
{
    return n == 0 || A[0] == B[n-1] && areReversed(A+1, B, n-1);
}

这有效：

• 如果n为零，则这两个数组彼此完全相反，因为它们都是空的。 （我们期望n不是负数。）
• 否则，我们将A的第一个元素与B的最后一个元素进行比较。 如果它们不相等，则此==和&&失败（为“false”生成零），并返回“false”，因为数组不是彼此颠倒的。
• 如果它们相等，我们还需要反转数组的其余部分，这由递归情况处理： A 的最后n-1元素（从A A+1开始）必须是第一个n-1的反转B的元素（从B开始）。

Answer 3

让我们首先从您的 function 声明开始。

int areReversed(int*, int*, int);

在 function 中传递的 arrays 不是在 function 中改变的吗？

所以相应的前两个 function 参数应该用限定符const声明

int areReversed( const int *, const int *, int);

C 中实体的大小也是size_t类型的值。 所以第三个参数的类型应该是size_t

int areReversed( const int *, const int *, size_t );

最后，使用大写字母作为标识符是个坏主意。

此外，如果第三个参数等于0 ，或者第一个数组的第一个元素等于第二个数组的最后一个元素，并且此条件对递归调用中两个 arrays 的其他元素有效，则 function 返回逻辑真function的。因此，只写一个带有上述逻辑表达式的return语句就足够了。

所以 function 可以这样定义

int areReversed( const int *a, const int *b, size_t n )
{
    return n == 0 || ( a[0] == b[n - 1] && areReversed( a + 1, b, n - 1 ) );
}

但是，如果您将第一个数组的第一个元素与第二个数组的最后一个元素进行比较，则可以减少 function 的递归调用次数，反之亦然，当您将第一个数组的最后一个元素与第一个数组的第一个元素进行比较时第二个数组。

在这种情况下，function 将如下所示。

int areReversed( const int *a, const int *b, size_t n )
{
    return ( n == 0 )                 || 
           ( n == 1 && a[0] == b[0] ) ||
           ( a[0] == b[n - 1] && a[n - 1] == b[0] && areReversed( a + 1, b + 1, n - 2 ) );
}

但是，如果 arrays 具有不同的元素类型怎么办？

在这种情况下，您必须编写另一个 function，例如当数组元素类型为double时。 此外，您必须以不同的方式命名 function，这只会让代码的读者感到困惑。

不幸的是，您不能像在 C++ 中那样重载 C 中的函数。

在这种情况下，解决问题的方法与bsearch和qsort等 C 标准函数中使用的方法相同。

也就是说，在这种情况下，您必须处理const void *类型的指针，并使用辅助 function 将const void *类型的指针转换为适当的指针类型。

在这种情况下，一般的 function 可以按照下面的演示程序所示的方式查看。

#include <stdio.h>

int areReversed( const void *a, const void *b,
                 size_t nmemb, size_t size,
                 int cmp( const void *, const void * ) )
{
    return ( nmemb == 0 )                ||
           ( nmemb == 1 && cmp( a, b ) ) ||
           ( cmp( a, ( const char * )b + ( nmemb - 1 ) * size ) &&
             cmp( b, ( const char * )a + ( nmemb - 1 ) * size ) &&
             areReversed( ( const char * )a + size, ( const char * )b + size, nmemb - 2, size, cmp ) );
}

static inline int cmp( const void *a, const void *b )
{
    return *( const int * )a == *( const int * )b;
}

int main( void )
{
    enum { N = 7 };
    int a[N] = { 1, 4, 6, 7, 5, 3, 2 };
    int b[N] = { 2, 3, 5, 7, 6, 4, 1 };

    printf( "The arrays are reversed relative to each other is %s.\n",
        areReversed( a, b, N, sizeof( int ), cmp ) ? "true" : "false" );
}

与 C++ 中的 C 相反，您可以使用标准算法std::equal例如

#include <iostream>
#include <iterator>
#include <algorithm>

template <typename T1, typename T2>
bool areReversed( const T1 &a, const T2 &b )
{
    return std::size( a ) == std::size( b ) &&
           std::equal( std::begin( a ), std::end( a ), std::rbegin( b ) );
}

int main()
{
    enum { N = 7 };
    int a[N] = { 1, 4, 6, 7, 5, 3, 2 };
    int b[N] = { 2, 3, 5, 7, 6, 4, 1 };

    std::cout << "The arrays are reversed relative to each other is " 
              << ( areReversed( a, b ) ? "true" : "false" ) << '\n';
}

请记住，如果您说您知道 C 而您不知道 C++，反之亦然，您知道 C++ 而您不知道 C 那么实际上这只是意味着您既不知道 C 也不知道 881464987:29888