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("%d\n", count_zeros(n));// For C++ std::cout << n << "\n";
  }
  return 0;
}

eg
输入：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 zeros\n", nums[i], count_zeros_recursive(nums[i]));
    }
    return 0;
}

Tested here

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("%d\n", *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));
}

用递归计数零不断崩溃

5 个答案: