Question

我最近发现一个C拼图写一个程序来读取一组整数x ₀，x ₁，x ₂，... ...。直到输入-1作为输入..

阅读-1后，程序应打印每个相邻数字之间的差异。即，x ₁ -x ₀，x ₂ -x ₁，x ₃ -x <子> 2 ，... ..

例如：输入：
1 2 4 7 11 -1

输出
1 2 3 4

输出是（2-1），（4-2），（7-4），（11-7）的结果

问题是程序不应该使用数组。即使动态分配的数组也不行。

我尝试了很多，这就是我带来的东西

#include<stdio.h>

int a, b;
int fn()
{
    int r=b-a;
    a=b;
    scanf("%d", &b);
    if(b!=-1)
    {
        printf("%d ", fn());
    }
    return r;
}

int main()
{
    scanf("%d%d", &a, &b);
    printf("%d ", fn() );
    return 0;
}

上面的程序使用递归函数，但在这种方法中，因为它就像一个堆栈，所以最后打印的值是先打印的，而不是先打印的值先打印出来。

即，与上述输入相同的输出是： 4 3 2 1 代替 1 2 3 4

有没有办法保存从这个调用堆栈中获取的值（如果我没有使用正确的术语，请纠正我）并再次将它们推入堆栈，这样在检索第一个计算值时，现在将是第一个弹出？

例如：我得到了值4,3,2和2; 1使用fn()，因为在弹出4之前它就像在堆栈上一样：

假设我弹出堆栈中的所有元素，并按弹出顺序将它们推送到另一个堆栈。然后新的堆栈将是

（即，4首先被弹出并推送（因此最终在底部），然后3被弹出和推动等等。）

如果可以这样做，我们可以从新堆栈中弹出元素并按照它们弹出的顺序显示它们。

注意：我所指的堆栈是调用堆栈＆amp;不是显式创建的堆栈（可能需要数组）。

或许有一种更简单的方法？

编辑：我需要将输入和输出阶段分开而不是交错。在使用-1发出输入结束信号之前，不应显示任何输出。

编辑：程序无法使用文件存储输入以便稍后读回。

Answer 1

有没有办法保存从这个调用堆栈中获取的值...并再次将它们推送到堆栈，这样在检索第一个计算值时，现在将是第一个被弹出的值？

每次读取数字时递归（除-1）。

创建一个由先前递归中的变量组成的链表。

除了printf()格式外，没有使用任何数组。

在上次打印int之后，需要做一些工作来避免空格。

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

typedef struct list {
  const struct list *prev;
  int i;
} list;

void print_list(const list *previous) {
  if (previous && previous->prev) {
    print_list(previous->prev);
    printf("%d ", previous->i - previous->prev->i);
  }
}

void JSfoo(const list *previous) {
  list node = { previous, 0 };
  int cnt = scanf("%d", &node.i);
  if (cnt == 1 && node.i != -1) {
    JSfoo(&node);
  } else {
    print_list(previous);
    puts("");
  }
}

int main(void) {
  JSfoo(NULL);
  return 0;
}

输出（不交错）

1 2 4 7 11 -1
1 2 3 4

另一种方法是维护一个队列，以消除递归打印的需要。相同的输出。

以下使用循环队列。请注意只需要1个next指针。队列句柄只需指向队列的末尾。不需要指向头部和尾部的指针。插入时间为O(1)。

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

typedef struct que {
  struct que *next;
  int i;
} que;

// Pass in the tail of the queue and return the updated tail
// `tail` points to the head.  (Circular queue)
que *que_append(que *tail, que *node) {
  if (tail) {
    node->next = tail->next;
    tail->next = node;
  } else {
    node->next = node;
  }
  return node;
}

void JSfoo(que *tail) {
  que node;
  int cnt = scanf("%d", &node.i);
  if (cnt == 1 && node.i != -1) {
    tail = que_append(tail, &node);
    JSfoo(tail);
  } else if (tail) {
    que *head = tail->next;
    while (head != tail) {
      printf("%d ", head->next->i - head->i);
      head = head->next;
    }
    puts("");
  }
}

Answer 2

您是否希望程序在输入“-1”后立即停止从用户那里获取更多输入字符，然后打印出差异序列？

如果没有，那就是如果你允许用户在“-1”之后输入更多的字符，程序会忽略直到输入换行符为止，那时你的程序可以打印出差异序列。然后，您可以使用以下代码段：

unsigned int x, y;
while( scanf("%d",&x)==1 && x != -1 && scanf("%d",&y)==1 && y != -1 )
    printf("%d ",y-x);
printf("\n");

编辑：感谢@JoëlHecht指出上述代码中的错误，我误读了所需的输出规范，以下代码应该修复它：

int x, y = -1;
while( scanf("%d",&x)==1 && x != -1 ) {
    if( y != -1 ) printf("%d ",x-y);
    y = x;
}
printf("\n");

Answer 3

这是一个需要递归函数的经典问题。递归函数（1）接受一个值并为退出条件提供测试以打破递归; （2）对数据进行一些操作;然后（3）再次调用自己（进行递归调用），导致进程重复。

在你的情况下，递归函数需要的值是（1）先前读取的整数然后它将从current读取stdin值（验证和处理任何错误）和测试退出条件的current是 -1。然后，该函数必须（2）打印current和previous之间的差异。然后需要（3）将current值作为参数传递给递归函数，再次调用自身直到满足退出条件。

将这些部分放在一起，您可以执行类似于以下difference()功能的操作：

#include <stdio.h>
#include <stdlib.h>  /* for EXIT_FAILURE */

/* recursive function taking previous read value as input */
void difference (int prev)
{
    int current;                /* variable to hold current value */

    if (scanf ("%d", &current) != 1) {  /* read / validate input */
        fprintf (stderr, "error: invalid input.\n");
        exit (EXIT_FAILURE);
    }

    if (current == -1)               /* recusion exit condition */
        return;

    printf (" %d", current - prev);         /* print difference */

    difference (current);     /* recursive call passing current */
}

int main (void) {

    int n;                          /* variable for first value */

    if (scanf ("%d", &n) != 1) {    /* read / validate input */
        fprintf (stderr, "error: invalid input.\n");
        exit (EXIT_FAILURE);
    }

    if (n == -1)                    /* verify not -1 */
        return 0;

    difference (n);     /* recursive call passing first value */

    putchar ('\n');     /* tidy up */

    return 0;
}

示例使用/输出

$ ./bin/diffints
1 2 4 7 11 -1
 1 2 3 4

使用辅助函数开始递归

如果你想在main()中稍微整理一下，可以创建一个辅助函数，它将读取第一个值并开始递归。这样只会在main()中调用辅助函数。这根本不会改变程序的运行。而不是调用和验证scanf的返回并在difference中第一次调用main()，而是将这些任务简单地移动到名为diffcheck()的新函数，然后调用{ {1}}开始递归。完全取决于你。

difference()

注意：如何将#include <stdio.h> #include <stdlib.h> /* for EXIT_FAILURE */ /* recursive function taking previous read value as input */ void difference (int prev) { int current; /* variable to hold current value */ if (scanf ("%d", &current) != 1) { /* read / validate input */ fprintf (stderr, "error: invalid input.\n"); exit (EXIT_FAILURE); } if (current == -1) /* recusion exit condition */ return; printf (" %d", current - prev); /* print difference */ difference (current); /* recursive call passing current */ } /* helper function to read 1st value and call difference */ void diffcheck (void) { int n; /* variable for first value */ if (scanf ("%d", &n) != 1) { /* read / validate input */ fprintf (stderr, "error: invalid input.\n"); exit (EXIT_FAILURE); } if (n == -1) /* verify not -1 */ return; difference (n); /* recursive call passing first value */ putchar ('\n'); /* tidy up */ } int main (void) { diffcheck(); return 0; }简化为对main()的单次调用，这比重复读取/验证更加清晰，并首先检查您要调用的所有地方<{1}}功能贯穿整个代码。

仔细研究，考虑diffcheck()的递归函数操作，如果您有任何其他问题，请告诉我。

Answer 4

该计划将

#include <stdio.h>

int main()
{
   unsigned int x, y;

   if(!(scanf("%d",&x)==1 && x != -1))
      return 0;

   while(scanf("%d",&y)==1 && y != -1 )
   {
        printf("%d ",y-x);
        x = y;
   }
   printf("\n");
}

Answer 5

以下是我提出的建议：

#include <stdio.h>

int a, b;
void fn()
{
    int r=b-a;
    a=b;

    scanf("%d", &b);
    printf("%d ", r);

    if(b!=-1)
        fn();
}

int main()
{
    scanf("%d%d", &a, &b);
    fn();
    printf("\n");
    return 0;
}

不使用数组

5 个答案: