C语言 使用递归计算零数不断崩溃

Question

我的代码应该使用递归来计算零的数量。

但是我的程序不断崩溃。

预期产出：

Input: 10500
Result: 3

法典：

void rCountZeros2(int num, int *result) {
if (num > 0) {
if ((num % 10) == 0) {
rCountZeros2((num / 10) + 1, *result);
}
rCountZeros2(num / 10, *result);
} else if (num == 0) {
*result = 1;
}
*result = num;
}

我如何让它工作？

Answer 1

这是使用和不使用指针
的解决方案 希望这有帮助

#include <stdio.h> // For C++ #include<iostream>
// Without using pointer
int count_zeros_recursive2(int num) {
if (num % 10 == 0) {
if (num > 19 || num < -19) {
return 1 + count_zeros_recursive2(num / 10);
}
return 1;
}
if (num > 19 || num < -19) {
return count_zeros_recursive2(num / 10);
}
return 0;
}
// Using pointer
void count_zeros_recursive(int num, int *result) {
if (num % 10 == 0)
*result = *result + 1;
if (num > 19 || num < -19)
count_zeros_recursive(num / 10, result);
}
int count_zeros(int num) {
int result = 0;
count_zeros_recursive(num, &result);
//result = count_zeros_recursive2(num);
return result;
}
int main() {
int n;
while (1) {
scanf("%d", &n); // For C++ std::cin >> n;
printf("%dn", count_zeros(n));// For C++ std::cout << n << "n";
}
return 0;
}

例如输入： 1010
输出： 2
输入： 0
输出： 1 输入： 10204012410
输出： 4
输入： -101
输出： 1

Answer 2

我更喜欢返回结果而不是将指针传递给结果。 停止条件是当数字为个位数时，如果为 0，则有 1 个零，否则为无。 如果数字不是单个数字，则计算没有最低数字的数字中的零数(num/10)，如果最低数字为 0，则在返回值上加 1。

#include <stdio.h>
int count_zeros_recursive(int num) 
{
int res = 0;
int num_without_lowest_digit = num/10;
if(num_without_lowest_digit == 0)
{
res = (num == 0);
}
else
{
res = count_zeros_recursive(num_without_lowest_digit);
if (num % 10 == 0)
{
res++;
}
}
return res;
}

int main(void) {
int nums[] = { 202, 7, 100, 10500, 10234, 10000};
int i;
for (i=0; i < sizeof(nums)/sizeof(nums[0]); ++i)
{
printf("Number %d has %d zerosn", nums[i], count_zeros_recursive(nums[i]));
}
return 0;
}

在这里测试

Number 202 has 1 zeros
Number 7 has 0 zeros
Number 100 has 2 zeros
Number 10500 has 3 zeros
Number 10234 has 1 zeros
Number 10000 has 4 zeros

Answer 3

假设您出于某种原因确实想使用指针。这是一个完整的解决方案：

#include <stdio.h>
void rCountZeros2(int num, int *result)
{
if(num>0)
{
if( (num % 10) == 0)
{
*result = *result + 1;
}
rCountZeros2(num/10, result);
}
}
int main() {
int i = 0;
int n;
n = scanf("%d", &n);
int *result = &i;
rCountZeros2(n, result);
printf("%dn", *result);
}

因此，将发生的情况是，您实际上只是在更新result指向的位置的值，这意味着您实际上只是将计数存储在变量i中。

Answer 4

如果可以使用函数方法，则无需传递指针。只需返回值。

long recursiveZeroesCount(long num) {
if(num == 0) return 1;
if(num < 10) return 0;
if(num % 10 == 0) return 1 + recursiveZeroesCount(num / 10);
else return recursiveZeroesCount(num / 10);
}

Answer 5

程序具有未定义的行为，因为您将*result的值而不是指向结果变量的指针传递给递归调用。 此外，您的算法存在缺陷，因为您无法递归地使用此 API，因为递归调用会更新结果以及当前调用，这是一种非常不切实际的情况。

这是一个没有递归的更正版本：

void rCountZeros2(int num, int *result) {
int count = 0;
for (;;) {
if (num % 10 == 0)
count++;
num /= 10;
if (num == 0)
break;
}
*result = count;
}

下面是一个具有更简单 API 的递归实现：

int rCountZeros2(int num) {
if (num % 10 == 0) {
if (num == 0)
return 1;
else 
return 1 + rCountZeros2(num / 10);
} else {
if (num < 10)
return 0;
else
return rCountZeros2(num / 10);
}
}

上述函数可以简化为单个语句：

int rCountZeros2(int num) {
return !(num % 10) + ((num < 10) ? 0 : rCountZeros2(num / 10));
}