用于在两个数组之间的相同位置上查找相同数字的递归函数答案

【问题标题】：Recursive function for finding same numbers on same positions between two arrays用于在两个数组之间的相同位置上查找相同数字的递归函数
【发布时间】：2015-01-07 20:55:45
【问题描述】：

这是一个结果应该是什么的例子：

1234 和 1344 在相同位置有两个数字。

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

int Proverka(int *num1[], int *num2[], int len, int pom) 
{   
    if (len < 1 && pom < 1)
        return 0;
    if (*num1 == *num2)
        return 1 + Proverka(num1++, num2++, len-1, pom-1);
    else {
        return Proverka(num1++, num2++, len-1, pom-1);
    }
}

int main (void)
{
    int *num1[5], *num2[5], pom, len, i, sin, j;

    pom = sizeof(num1) / sizeof(num1[0]);
    len = sizeof(num2) / sizeof(num2[0]);

    for (i = 0; i < pom; i++) {
        printf("Enter elements for first array :");
        scanf("%d", num1[i]);
    }

    for (j = 0; j < len; j++){
        printf("Enter elements for second array : ");
        scanf("%d", num2[j]);
    }

    sin = Proverka(num1, num2, pom, len);

    {
        printf("They have %d numbers on same positions", sin);
    }   
    return 0;
}

【问题讨论】：

@G.Samaras 就在那里。
你的代码看起来很烦人，请适当缩进，这样写代码真的很糟糕，这是个好建议，赶紧改正吧。
那么问题是什么？
我已经格式化了。你们不要再用另一个编辑把它搞砸了。
@theAlias 它不工作，我需要知道如何让它工作。

标签： c function recursion

【解决方案1】：

您的代码中有很多错误，这是它的工作版本。

阅读 cmets 以了解我所做的更改。

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

int Proverka(int *num1, int *num2, int len1, int len2)
{
    if (len1 < 1 && len2 < 1) return 0;
    // note the pre-increment. Your post-increment wouldn't have worked. Or just add 1.
    return (*num1 == *num2) + Proverka(++num1, ++num2, len1 - 1, len2 - 1);
    // this works, since "boolean" is really just 0 or 1
}

int main (void)
{
    // I make array of ints, not of pointers to ints.
    int num1[5], num2[5], len1, len2, i, same;
    len1 = sizeof(num1) / sizeof(num1[0]);
    len2 = sizeof(num2) / sizeof(num2[0]);

    for (i = 0; i < len1; i++) {
        printf("First array element %d:", i+1);
        scanf("%d", &num1[i]); // pointer at the element
    }

    for (i = 0; i < len2; i++){
        printf("Second array element %d:", i+1);
        scanf("%d", &num2[i]);
    }

    // get pointers at the first array elements
    same = Proverka(&num1[0], &num2[0], len1, len2);
    printf("They have %d numbers on same positions\n", same); // newline - good practice
    return 0;
}

这里有一个更“优化”和清理的版本：

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

#define ITEMS 5

int Proverka(const int *aa, const int *bb, const int len)
{
    if (len == 0) return 0;
    return (*aa == *bb) + Proverka(1 + aa, 1 + bb, len - 1);
}

int main (void)
{
    int aa[ITEMS], bb[ITEMS], i, same;

    for (i = 0; i < ITEMS; i++) {
        printf("First array element %d:", i+1);
        scanf("%d", &aa[i]);
    }

    for (i = 0; i < ITEMS; i++) {
        printf("Second array element %d:", i+1);
        scanf("%d", &bb[i]);
    }

    same = Proverka(&aa[0], &bb[0], ITEMS);
    printf("They have %d numbers on same positions\n", same);
    return 0;
}

为此使用递归不是一个很好的选择，循环会更容易和更安全。但这也适用 - 对于不太大的数组。

【讨论】：

既然你注意到了，我也应该注意到。注意甚至不需要预增量。在调用递归之前，无需将此值保留到 num1 和 num2。 num1+1 和 num2+1 就足够了。
是的，我并没有真正为优化而烦恼，它只会让 OP 感到困惑。我猜你应该可以把所有的论点都设为常量。
非常感谢，所有强大的猪肉！嗯，我想我已经接近了..不知何故。 :D 为什么返回 (*num1=*num2) ？
@WhozCraig 检查我的第二个版本，这个版本有什么错误吗？
@Lolapanza 如果它们相等，则为 1，否则为 0。这与您对 ifs 所做的相同，只是要短得多。也许最好使用(*aa == *bb ? 1 : 0) 来确保它是1，因为True 通常是非零的。但它似乎像这样工作。

【解决方案2】：

int *num1[5],*num2[5] ...不会给你一个分配了内存的整数指针数组。修复它。使用 malloc 分配内存。

或者直接说int num1[5],num2[5]和scanf("%d",&num1[i]);

【讨论】：