为什么即使没有基本情况，递归也能工作？

Question

我正在学习递归，所以我正在尝试创建一个程序，以递归方式反转数组中的数字并使用分而治之技术（我不确定这是否是分而治之），所以我的问题是什么是，我想知道为什么如果我删除第 11 行程序仍然可以正常工作，但如果我删除第 16 行，它会无限运行。
我检查了我的调试器，我知道为什么它是无限循环，因为每个堆叠的帧索引左仍然小于右，这使得循环无限，所以我的问题，为什么递归调用从检查 while 条件开始并跳过该行11？这对我来说很奇怪，因为我只是学习了一些递归的基础知识，所以这对我来说有点困惑。所以在我的代码中，第 16 行被认为是基本情况？因为我从教程中了解到递归需要一个基本案例。

#include <stdio.h>
#define size 10
void swap(int *a, int *b)
{
    int temp= *b;
    *b = *a;
    *a = temp;
}
void revcur (int arr[], int left, int right)
{
    if (left>=right) return; //This program still works even if i delete this line or comment 
    while (left<right)
    {
        swap(&arr[left],&arr[right]);
        revcur(arr,left+1,right-1);
        return; //This program will go to infinite recursive if i delete this
    }
}
int main()
{
    int arr[size]={1,2,3,4,5,6,7,8,9,10};
    revcur(arr,0,size-1);
    int i; for (i=0; i<size; i++)
    {
        printf("%d ",arr[i]);
    }
}

Answer 1

假设左=2，右=1。如果您将第 11 行留在其中，条件将为真，您将立即退出函数（返回）。当您删除第 11 行时，您将进入 while 循环。 while 语句检查 left 是否小于 right，事实并非如此。因此，它将跳过 while 循环中的所有代码，从而将您带到函数的末尾，因此它将自动返回。这与保留第 11 行的情况相同。

删除第 16 行时它无限循环的原因是因为您没有将“左”和“右”更新为新值。所以如果left确实小于right，它会进入循环，因为left和right的值永远不会改变，所以下次它到达“while”语句的那一行时，“left”仍然会小于“right” "，因此循环将无限期地继续。

Answer 2

此代码模式：

while (condition)
{
    // do something
    return;
}

完全等价于

if (condition)
{
    // do something
    return;
}

换句话说，您的基本情况是!condition。

---

你可以用

替换你的实现

void revcur(int arr[], int left, int right)
{
    if (left>=right) return;

    swap(&arr[left],&arr[right]);
    revcur(arr,left+1,right-1);
}

这将是完全等价的（while 从未真正循环过）。

---

您的版本似乎有迭代等价物的痕迹：

void revcur(int arr[], int left, int right)
{
    while (left<right) {
        swap(&arr[left++],&arr[right--]);
    }
}

Answer 3

你的函数过于复杂，其实就是这么干的：

void revcur(int arr[], int left, int right)
{
  if (left<right)
  {
    swap(&arr[left], &arr[right]);
    revcur(arr, left + 1, right - 1);
  }
}

原始函数中的 while 循环永远不会循环超过一次，因此具有 while 实际上毫无意义；这只是写if的一种奇怪的方式。

考虑以下函数。

void foo(int x)
{
  printf("x = %d\n",x );

  if (x > 0)
    foo(x - 1);
}


void bar(int x)
{
  printf("x = %d\n", x);

  while (x > 0)
  {
    bar(x - 1);
    return;
  }
}

foo 和 bar 做同样的事情，只是 bar 滥用 while 循环，将其用作 if，就像您在函数中所做的那样。

现在尝试从bar 函数中删除return，看看会发生什么。

Answer 4

你的函数是void。所以最后一次你在递归中调用它。它不会进入while循环，因此不会再次调用该函数，从而结束递归。而且因为 ypu 在你的 while 循环中有一个返回，我想你可以用 if 语句替换它，它基本上会做同样的事情，你可以摆脱 return。

Answer 5

此声明

if (left>=right) return; //This program still works even if i delete this line or comment 

只是多余的。

如果left >= right为真，那么while语句left < right的条件为假，while循环将不会被执行。

所以你可以删除 if 语句。

void revcur (int arr[], int left, int right)
{
    while (left<right)
    {
        swap(&arr[left],&arr[right]);
        revcur(arr,left+1,right-1);
        return; //This program will go to infinite recursive if i delete this
    }
}

但是，您可能不会删除 return 语句，因为在这种情况下，循环将是无限的，因为在循环内部变量 left 和 right 本身的值没有改变，而 while 的条件如果最初评估为 true，则语句将始终评估为 true。

另一方面，使用 while 语句是没有意义的，因为在任何情况下，由于 return 语句，假设循环体只会执行一次。重要的是 while 语句的条件。

所以你可以用 while 语句代替 if 语句。

例如

void revcur (int arr[], int left, int right)
{
    if ( left < right)
    {
        swap(&arr[left],&arr[right]);
        revcur(arr,left+1,right-1);
    }
}

考虑到如果数组只包含一个元素，那么它将与自身交换，即该函数将有一个多余的递归调用。

该函数可以重写为只有两个参数，并且本身没有多余的递归调用。

下面是一个演示程序，展示了如何使用两个参数编写函数。

#include <stdio.h>

void swap( int *a, int *b )
{
    int temp= *b;
    *b = *a;
    *a = temp;
}

void reverse( int a[], size_t n )
{
    if ( !( n < 2 ) )
    {
        swap( &a[0], &a[n-1] );
        reverse( a + 1, n - 2 );
    }
}

int main(void) 
{
    int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    const size_t N = sizeof( a ) / sizeof( *a );

    for ( size_t i = 0; i < N; i++) printf( "%d ", a[i] );
    putchar( '\n' );

    reverse( a, N );

    for ( size_t i = 0; i < N; i++) printf( "%d ", a[i] );
    putchar( '\n' );

    return 0;
}

程序输出是

1 2 3 4 5 6 7 8 9 10 
10 9 8 7 6 5 4 3 2 1