Рекурсивный способ проверить, имеют ли 2 массива одинаковые элементы

Question

Я напишу функцию, чтобы проверить, имеют ли 2 массива одинаковые элементы. но я хочу сделать рекурсивную функцию для проверки этого. у вас есть идеи для этого? например здесь массива AB и выход:

A: [2 4 5 4]

B: [4 5 2 4]

из положить 1

вне положенный должно быть 1, если то же самое и 0, если нет.

здесь моя регулярная функция:

#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
#include <time.h> 
#include <assert.h> 
int partition(int *a, int left, int right) 
{ 

    int first = left; 
    int pivot; 
    int pos; 
    srand((unsigned)time(NULL)); 
    pos = rand() % (right - left + 1) + left; 
    swap(a + first, a + pos); 
    pivot = a[first]; 

    while (left<right) 
    { 
     while (a[right] > pivot) right--; 
     while ((left < right) && (a[left] <= pivot)) left++; 
     if (left < right) 
      swap(a + left, a + right); 
    } 
    pos = right; 
    a[first] = a[pos]; 
    a[pos] = pivot; 
    return pos; 
} 
void quick_sort(int *a, int first, int last) 
{ 
    int pos; 
    if (first<last) 
    { 
     pos = partition(a, first, last); 
     quick_sort(a, first, pos - 1); 
     quick_sort(a, pos + 1, last); 
    } 
} 
int *input_array_dyn(int n) 
{ 
    int i; 
    int *a; 
    a = (int *)calloc(n, sizeof(int)); 
    assert(a); 
    printf("enter the array of length %d\n", n); 
    for (i = 0;i<n;i++) 
     scanf_s("%d", a + i); 
    return a; 
} 
int part1_excute(int *a, int *b, int n) 
{ 
    int index; 
    int ans = 1; 
    quick_sort(a, 0, n - 1); 
    quick_sort(b, 0, n - 1); 
    for (index = 0;index<n;index++) 
    { 
     if (a[index] != b[index]) 
      ans = 0; 
    } 
    if (ans == 0) return 0; 
    else return 1; 
    free(a); 
    free(b); 
} 

void main() 
{ 
    int *a, *b; 
    int ans = 1; 
    int size; 
    printf("Please input the size of array\n"); 
    scanf_s("%d", &size); 
    printf("First array:\n"); 
    a = input_array_dyn(size); 
    printf("Second array:\n"); 
    b = input_array_dyn(size); 
    printf("If the output is 1, the arrays are the same.\n"); 
    printf("If the output is 0, the arrays are the not same.\n"); 
    printf(" The ans is: %d\n", part1_excute(a,b,size)); 

}

Answer 1

Я думаю, что вы ищете это: -

/* created to help alex :)*/ 
#include<stdio.h> 

int x[] = {'a', 'b', 'c', 'd'}; 
int y[] = {'d', 'a', 'c', 'b'}; 

/* core logic, which will iterate recursively. 
    to more accurately understand this logic, you should use 
    x[] = {'a', 'b', 'c', 'd'}; 
    y[] = {'e', 'f', 'g', 'h'}; 

    for your question replace x and y with 
    x[] = {2, 4, 5, 4}; 
    y[] = {4, 5, 2, 4}; 

    i am apologizing if names of variables or functions are inappropriate. 
    If program is not compiling there should be some syntax errors but logic is tested OK 
*/ 
int compare(int *x, int lx, int *y, int ly, int called){ 
    int len = 0; 
    if(ly == 0 || lx == 0) 
     return 0; 
    printf("comparing %c %c\n",*x,*y); 
    if(*x == *y) 
     len += 1; 
    if(called) 
     len += compare(x+1,lx-1,y,ly,called-1); 
    len += compare(x,lx,y+1,ly-1,0); 
    return len; 
} 

/* returns true or false after calling the core logic */ 
int wraper_compare(int *x, int lx, int *y, int ly){ 
    int len; 
    if (ly > lx){ 
     len = compare(x,lx,y,ly,lx); 
     if (len == lx) 
      return 1; 
     else 
      return 0; 
    } else { 
     len = compare(x,lx,y,ly,ly); 
     if(len == ly) 
      return 1; 
     else 
      return 0; 
    } 
} 

int main(){ 
    printf("%d \n",wraper_compare(x,4,y,4)); 
    return 0; 
} 

я использовал массив с 'а', 'б' , 'c', 'd', чтобы вы могли проверить рекурсивную логику. Это будет использовать итерацию MxN, если M - размер x, а N - размер y.

это работает, если: - 1. Обычный случай (т. Е. Одинаковые длины массивов и отсутствие дублирования элементов в одном массиве) 2. дублировать элементы несколько раз. 3. различные длины. (в этом случае возвращается 1, если меньшее является подмножеством большего размера)

Благодарим за предоставленную мне возможность подумать. В течение долгого времени (по крайней мере, год) искал этот материал. Еще раз спасибо за то, что вы задали такой вопрос . +1 для этого (уже задано)

Я думаю, что прошел тест. Пожалуйста, дайте мне знать результат :) :)