Question

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
          //  0  1  2  3  4  5  6  7
int arr[] = { 3, 6, 1, 2, 6, 7, 8, 4};
int bee[] = { 6, 8, 1, 4, 2, 6, 3, 7};
int i = 0;
int j = 0;
int matches[120] = {0};
int length1 = 8;

void find_matches(int *arr, int *bee, int*matches);

void find_matches(int *arr, int *bee, int *matches)
{
    for (i = 0; i<length1; i++)
    {
        for (j = 0; j < length1; j++)
        {
            if (arr[i]==bee[j])
            {
                matches[i] = j;
            }
        }
    }

    for (int z = 0; z<8; z++)
    {
        printf("%d\n", matches[z]);
    }
}

int main()
{
    find_matches(arr, bee, matches);
}

我的代码的要旨是，它将arr[]到bee[]的每个值都匹配，并将匹配的索引作为数字放入matches数组和打印中。

例如，arr[0]中的值3与bee[5]中的值3匹配，因此matches[0]的值将为5。

如何将其转换为递归函数？

我尝试保留外部for循环并在内部使用递归函数调用运行外部，但是我不知道如何设置变量等。

Answer 1

在两个数组上进行两次递归-请参见注释：

// recursives
void find_matches(int *arr, int *bee, int *matches, int current_position_in_arr);
void find_matches_in_bee(int *arr, int *bee, int *matches, int current_position_in_arr, int current_position_in_bee);

// wrapper
void find_matches(int *arr, int *bee, int *matches) {
    find_matches(arr, bee, matches, 0);
}

// outer loop : iterate over 'arr'
void find_matches(int *arr, int *bee, int *matches, int current_position_in_arr) {
    // check where arr[current_position_in_arr] is present in bee
    find_matches_in_bee(arr, bee, matches, current_position_in_arr, 0);

    // "next iteration of loop" - we check the next element in arr
    if (current_position_in_arr + 1 < length) {
        find_matches(arr, bee, matches, current_position_in_arr + 1);
    }
}

// inner loop : iterate over 'bee'
void find_matches_in_bee(int *arr, int *bee, int *matches, int current_position_in_arr, int current_position_in_bee) {
    // do your business magic
    if (arr[current_position_in_arr] == bee[current_position_in_bee]) {
       ....
    }

    // "next iteration of loop" - we check the next element in bee
    if (current_position_in_bee + 1 < length) {
        find_matches_in_bee(arr, bee, matches, current_position_in_arr, current_position_in_bee + 1);
    }
}

以与以前相同的方式调用：

find_matches(arr, bee, matches);

这里的教训是您可以替换以下内容：

int *array;

for (int i = 0; i < LEN; ++i) {
  f(array[i]);
}

使用

void f(int *array) {
  f_inner(array, 0);
}

void f_inner(int *array, int position) {
  // business logic on array[position]

  // iteration step
  if (position + 1 < LEN) {
    f_inner(array, position + 1);
  }
}

Answer 2

像这样：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
          //  0  1  2  3  4  5  6  7
int arr[] = { 3, 6, 1, 2, 6, 7, 8, 4};
int bee[] = { 6, 8, 1, 4, 2, 6, 3, 7};
int matches[120] = {0};
int length1 = 8;

void find_matches(int *arr, int *bee, int *matches, int i)
{
    if (i == length1)
        return ;
    for (int j = 0; j < length1; ++j)
        if (arr[i]==bee[j])
            matches[i] = j;
    printf("%d\n", matches[i]);
    find_matches(arr, bee, matches, i + 1);
}

int main()
{
    find_matches(arr, bee, matches, 0);
    return 0;
}

Answer 3

您的代码干净，清晰，如嵌套循环所示。您为什么要谨慎地将其转换为递归？如果您真的想要，

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
          //  0  1  2  3  4  5  6  7
int arr[] = { 3, 6, 1, 2, 6, 7, 8, 4};
int bee[] = { 6, 8, 1, 4, 2, 6, 3, 7};
int i = 0;
int j = 0;
int matches[120] = {0};
int length1 = 8;

// iterate over bee
void match(int i, int j)
{
    if (j < 0)
        return;
    if (arr[i] == bee[j]) {
        matches[i] = j;
        return;
    }
    match(i, j - 1);
}

// iterate over arr
void fit(int i)
{
    if (i > 7)
        return;
    match(i, 7);
    fit(i + 1);
}

void find_matches_recursively()
{
    fit(0);
    for (int z = 0; z < 8; z++)
        printf("%d\n", matches[z]);        
}

int main()
{
    find_matches_recursively();
}

输出

与您的代码相同。

注意：bee[8]中有重复的值（位置0和位置5的值6）。您的迭代将遍历所有值并记录最后一个匹配项。我的递归从尾部开始搜索，并在找到第一个匹配项时立即返回。效果是一样的。

将嵌套的for循环转换为C中的递归

3 个答案: