C 带十进制输入的递归函数以二进制形式打印从零到n的所有数字

我的家庭作业是写一个递归函数，它输出从零到n的所有二进制数，一个输入整数。禁止使用循环、静态变量、数组和全局变量

例如，如果输入为7，则输出应为：

000
001
010
011
100
101
110
111

我的输出：

1
10
11
100
101
110
111

我如何用这些零来修正我的输出

这是我的密码：

#include <stdio.h>


void convert(int num)//converts decimal number to binary
{
    if(num>0)
    {
    convert(num/2);
    printf("%d", num%2);
    }
}

void print_binary_number(int num)
{
    if(num<0)
       return;
    print_binary_number(num-1);
     printf("\n");
    convert(num);

}

int main()
{

    int num;
    printf("Please enter an integer:");
    scanf("%d", &num);
    print_binary_number(num);
    return 0;

}

#包括
void convert（int num）//将十进制数转换为二进制数
{
如果（数值>0）
{
转换（num/2）；
printf（“%d”，数量%2）；
}
}
无效打印二进制数（整数）
{
if（num一种方法是查找C中格式化“前导零”的各种方法。然而，我通常认为讲师希望解决的方法是将其作为字符串处理问题来处理

空的情况很简单：返回值为“”

对于下一个扩展，返回两组字符串：前一组前面有“0”，前一组前面有“1”

0
and
1

重复此过程，直到需要2的任意幂：

00
01
and
10
11

然后

这就足够让你动起来了吗？
一种方法是查找C中格式化“前导零”的各种方法。然而，我通常看到讲师希望解决这个问题的方法是将其作为字符串处理问题来处理

空的情况很简单：返回值为“”

对于下一个扩展，返回两组字符串：前一组前面有“0”，前一组前面有“1”

0
and
1

重复此过程，直到需要2的任意幂：

00
01
and
10
11

然后

这足以让你动起来吗？
找出有多少个零：

#include <limits.h>
#define BITS_IN_INT (sizeof(int) * CHAR_BIT)
// would keep the strings small and legible, but the above gives the correct value
// #define BITS_IN_INT 8

// recurse until first set bit is reached
int number_of_leading_zeros(int n, int count){
  if(n != 0){
    count--;
    n >>= 1;
    return number_of_leading_zeros(n, count);
  } 
  return count;
}

然后在转换后的号码之前打印它们

// simple loop, made recursive
void print_leading_zeros(int n){
  if(n != 0){
     putchar('0');
     n--;
     print_leading_zeros(n);
  }
}

如果“必须是递归”这件事是我的误解，请随意使用循环进行交换。
找出有多少个零：

#include <limits.h>
#define BITS_IN_INT (sizeof(int) * CHAR_BIT)
// would keep the strings small and legible, but the above gives the correct value
// #define BITS_IN_INT 8

// recurse until first set bit is reached
int number_of_leading_zeros(int n, int count){
  if(n != 0){
    count--;
    n >>= 1;
    return number_of_leading_zeros(n, count);
  } 
  return count;
}

然后在转换后的号码之前打印它们

// simple loop, made recursive
void print_leading_zeros(int n){
  if(n != 0){
     putchar('0');
     n--;
     print_leading_zeros(n);
  }
}

如果“必须是递归”这件事是我的误解，请随意使用循环进行交换。
以下是我的解决方案（只需对代码进行最小的更改）：

#包括
无效转换（整数、整数限制）
{
如果（限制>0）
{
转换（num/2，limit/2）；
printf（“%d”，数量%2）；
}
}
无效打印二进制数（整数、整数限制）
{
如果（数值>限制）
回来
转换（num，limit）；
printf（“\n”）；
打印二进制数（num+1，限制）；
}
int main（）
{
int-num；
printf（“请输入一个整数：”）；
scanf（“%d”和&num）；
打印二进制数字（0，num）；
返回0；
}

convert
函数现在接受两个参数，而不是一个参数：除了要打印的数字外，它还接收
limit
、用户输入和循环的最终值。它使用
num
生成二进制数字，但使用
limit
决定何时停止打印。这具有生成零的效果直到达到
限制的大小。
以下是我的解决方案（对代码进行最小更改）：

#包括
无效转换（整数、整数限制）
{
如果（限制>0）
{
转换（num/2，limit/2）；
printf（“%d”，数量%2）；
}
}
无效打印二进制数（整数、整数限制）
{
如果（数值>限制）
回来
转换（num，limit）；
printf（“\n”）；
打印二进制数（num+1，限制）；
}
int main（）
{
int-num；
printf（“请输入一个整数：”）；
scanf（“%d”和&num）；
打印二进制数字（0，num）；
返回0；
}

convert
函数现在接受两个参数，而不是一个参数：除了要打印的数字外，它还接收
limit
、用户输入和循环的最终值。它使用
num
生成二进制数字，但使用
limit
决定何时停止打印。这具有生成零的效果直到达到
limit
的大小。
以下只会导致递归深度为log2（n）。使用深度为
n
的递归会给递归带来坏名声

没有循环、静态变量、数组、全局变量。也没有类似于数组但在技术上是字符序列的字符串文本

print\u binary\u numbers\u ll（）
在每一步调用两条路径。一条路径带有
'0'
，另一条路径带有
'1'
。一旦达到最低有效位，就会递归打印
数字\u ll
列表

#include <stdio.h>

typedef struct digit_ll {
  int digit;
  struct digit_ll *previous;
} digit_ll;

void print_ll(const digit_ll *prev) {
  if (prev) {
    print_ll(prev->previous);
    putchar(prev->digit);
  }
}

void print_binary_numbers_ll(int num, digit_ll *prev) {
  if (num <= 0) {
    print_ll(prev);
    putchar('\n');
  } else {
    digit_ll current = { '0', prev };
    print_binary_numbers_ll(num / 2, &current);
    current.digit = '1';
    print_binary_numbers_ll(num / 2, &current);
  }
}

void print_binary_numbers(int num) {
  print_binary_numbers_ll(num, 0);
}

int main() {
  print_binary_numbers(3);
  print_binary_numbers(7);
}


要将0打印到
n
，即使
n
不是2-1的幂，并且仍然只递归
log2（n）
最大深度，并且不使用链表：

static void print_b(int value, int limit) {
  if (limit) {
    print_b(value/2, limit/2);
    putchar('0' + value%2);
  }
}

static void print_binary_numberR(int depth, int value, int limit) {
  if (depth) {
    print_binary_numberR(depth/2, value*2 + 0, limit);
    print_binary_numberR(depth/2, value*2 + 1, limit);
  } else if (value <= limit) {
    print_b(value, limit);
    putchar('\n');
  }
}

void print_binary_numbers(int num) {
  print_binary_numberR(num, 0, num);
}

print_binary_numbers(3);
print_binary_numbers(4);

以下内容只会导致递归深度为log2（n）。使用深度为
n
的递归会给递归带来坏名声

没有循环、静态变量、数组、全局变量。也没有类似于数组但在技术上是字符序列的字符串文本

print\u binary\u numbers\u ll（）
在每一步调用两条路径。一条路径带有
'0'
，另一条路径带有
'1'
。一旦达到最低有效位，就会递归打印
数字\u ll
列表

#include <stdio.h>

typedef struct digit_ll {
  int digit;
  struct digit_ll *previous;
} digit_ll;

void print_ll(const digit_ll *prev) {
  if (prev) {
    print_ll(prev->previous);
    putchar(prev->digit);
  }
}

void print_binary_numbers_ll(int num, digit_ll *prev) {
  if (num <= 0) {
    print_ll(prev);
    putchar('\n');
  } else {
    digit_ll current = { '0', prev };
    print_binary_numbers_ll(num / 2, &current);
    current.digit = '1';
    print_binary_numbers_ll(num / 2, &current);
  }
}

void print_binary_numbers(int num) {
  print_binary_numbers_ll(num, 0);
}

int main() {
  print_binary_numbers(3);
  print_binary_numbers(7);
}


要将0打印到
n
，即使
n
不是2-1的幂，并且仍然只递归
log2（n）
最大深度，并且不使用链表：

static void print_b(int value, int limit) {
  if (limit) {
    print_b(value/2, limit/2);
    putchar('0' + value%2);
  }
}

static void print_binary_numberR(int depth, int value, int limit) {
  if (depth) {
    print_binary_numberR(depth/2, value*2 + 0, limit);
    print_binary_numberR(depth/2, value*2 + 1, limit);
  } else if (value <= limit) {
    print_b(value, limit);
    putchar('\n');
  }
}

void print_binary_numbers(int num) {
  print_binary_numberR(num, 0, num);
}

print_binary_numbers(3);
print_binary_numbers(4);

哦，我明白你在做什么了。我不清楚如何正确地对它进行参数化（即生成小于等于
n
）的数字。使用字符串数组。继续，直到数组大小至少是你的输入
n
。或者，取log2（n），四舍五入，并重复多次。不允许使用数组。
log2（n）
是不允许的。哦，我知道你在做什么。我不清楚如何正确地对它进行参数化（即生成小于等于
n
）的数字。使用字符串数组。继续，直到数组大小至少是你的输入
n
。或者，取log2（n），四舍五入，并重复许多级别。数组是不允许的。
log2（n）
不是