C 如何将整数数组的所有项递归地移动到第一个单元格？

我很难处理递归。 我需要编写一个递归调用的函数来比较两个整数数组。 函数接收两个数组及其相应的长度

数组包含数字。 我的目标是最终将每个数组的所有项移动到数组的第一个单元格，并让退出条件比较数组的前两个单元格。 因为这是一个整数数组，所以我无法理解如何将数字从下一个单元格“串联”到上一个单元格，以及通常如何完成整个过程。 我非常希望你能给我一个答案或一个提示

说明：

该函数将使用两个数组作为参数，它们的长度分别为[1234567891]和[12345,6,78,91]。我的函数需要返回这两者是否相等

我的想法是，我以某种方式递归地将两个数组中的所有项相应地移动到第一个单元格，然后在最终返回条件下比较单元格，谢谢

很明显，这可以用另一种方式来实现，对我来说，哪种方式有效并不重要，只要它有效：D

[编辑]：

以下是一些可能的比较：

compare( [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]) => SAME
compare( [12, 34, 5], [1, 2, 3, 4, 5]) => SAME  
compare( [12, 34, 5], [123, 45]) => SAME
compare( [1, 2], [5, 6]) => DIFFER

---

特定于数字“连接”：

如果您真的想“连接”两个数字，一种可能的方法是：

假设有两个数字n1和n2，其中n2中的位数是m。然后，按照您的示例，连接它们的方法是n1*10m+n2

因此，对于235和236543，连接将是235*106+23645=235236543 在本例中，我们不检查数组是否相等（请参见下文），而是检查表示为字符串的数字是否相等，然后连接。例如：

[1,2,3,4,5] === [12,34,5] === [123,45]

其思想是，我们对每个数组进行遍历，以表示的字符串作为最终值，以空字符串作为初始值，取每个整数，将其转换为字符串，并在结果末尾将其连接起来。然后我们发现自己有两个字符串，我们比较它们是否相等

请注意，我的解决方案有几个问题

首先，我没有对字符串操作进行任何绑定检查，因此下面的代码将愉快地践踏您的内存

我们也不跟踪结果的结尾，这意味着每个连接都需要遍历结果字符串，这不是一种有效的方法

给出的itoa实现的一个限制是，对于最大的负整数，它不能正常工作

不过，总的想法还是一样的。用一种好的编程语言，您可以编写：

(eq?     
  (reduce concat "" (map tostr [1,2,3,4,5] ))
  (reduce concat "" (map tostr [1,2,3,4,5] )))

或同等品；但这是C，所以我们必须用艰难的方式：

#include <assert.h>
#include <string.h>

#define SAME 0
#define DIFFER 1

void reverse(char s[]);
void itoa(int n, char s[]);

void reduce_to_string(char *result, int values[], int values_len){
  char tmpstr[256] = "";

  if( values_len == 0 ){ return; }

  // convert the first number to a string, writing the representation to tmpstr
  itoa(values[0], tmpstr);

  // concatenate the first number with the accumulated string
  result = strcat(result, tmpstr);

  // recur with a smaller array.
  return reduce_to_string(result, &values[1], (values_len-1));
}

int compare_representation(int a[], int a_len, int b[], int b_len){
  char a_as_string[512] = "";
  char b_as_string[512] = "";

  reduce_to_string(a_as_string, a, a_len);
  reduce_to_string(b_as_string, b, b_len);

  if( 0 == strcmp(a_as_string, b_as_string) ){ return SAME;}

  return DIFFER;
}


int main(void){

  int b[] = {6,7,8,9};
  int b_len = 4;

  int c[] = {1,2,3,4,5};
  int c_len = 5;

  int d[] = {67, 89};
  int d_len = 2;

  assert(SAME == compare_representation(b,b_len,d,d_len));
  assert(DIFFER == compare_representation(b,b_len,c,c_len));

  return 0;
}



/*
 * The following are from K&R C, second edition.
 */

/* reverse:  reverse string s in place. page 62 */
void reverse(char s[])
{
    int i, j;
    char c;

    for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

/* itoa:  convert n to characters in s. page 64*/
void itoa(int n, char s[])
{
    int i, sign;

    if ((sign = n) < 0)  /* record sign */
        n = -n;          /* make n positive */
    i = 0;
    do {       /* generate digits in reverse order */
        s[i++] = n % 10 + '0';   /* get next digit */
    } while ((n /= 10) > 0);     /* delete it */
    if (sign < 0)
        s[i++] = '-';
    s[i] = '\0';
    reverse(s);
}

---

连接一个数字意味着什么？我的意思是，如果我的原始数组看起来像[235][236543][123]，我最终希望实现[235236543123]（以下单元格的内容无关紧要）。一些示例代码可能会很有用。听起来好像您想通过使用字符串比较聚集在一起的数字来比较一系列数字。我添加了一个示例。请注意，我不能使用循环。我认为这是不对的，因为如果数组大小不同，并不意味着它们不相等。因为在我的例子中，相等性是由数字定义的，无论它们在哪个单元格中（[123][45][6]）都等于[12345][6]，也等于[12][34][5][6]。那么你就不能比较数组的相等性了。你真的担心数字的字符串表示吗？是的，我需要两个字符串中的数字相等并且顺序相同。不，数字不相等。它们的串联字符串表示形式将为。这在你的问题中是不清楚的。解决方案有点复杂。请阅读并告诉我您的想法。通过将

result+strlen（result）

传递到递归调用中的第一个参数，您可以解决

将\u缩减为\u字符串的效率问题。一旦进行了更改，就不再需要
tmpstr
，您可以直接在
result
上应用
itoa（）
。
#include <assert.h>

#define SAME 0
#define DIFFER 1

int compare_recursive(int a[], int a_len, int b[], int b_len){
  if( a_len != b_len ){ return DIFFER; }
  if( a_len == 0 && b_len == 0 ){ return SAME; }
  if(a[0] == b[0]){
    return compare_recursive(&a[1], (a_len-1), &b[1], (b_len-1) );
  }else{
    return DIFFER;
  }
}

int compare_iterative(int a[], int a_len, int b[], int b_len){
  int i;
  if( a_len != b_len ){ return DIFFER; }
  for(i = 0; i < a_len; i++){
    if( a[i] != b[i] ){ return DIFFER; }
  }
  return SAME;
}

int main(void){
  int a[] = {1,2,3,4,5};
  int a_len = 5;

  int b[] = {6,7,8,9};
  int b_len = 4;

  int c[] = {1,2,3,4,5};
  int c_len = 5;

  assert(DIFFER == compare_recursive(a,a_len,b,b_len));
  assert(SAME == compare_recursive(a,a_len,c,c_len));

  assert(DIFFER == compare_iterative(a,a_len,b,b_len));
  assert(SAME == compare_iterative(a,a_len,c,c_len));

  return 0;
}