Как объединить два массива с разными значениями в один массив?

Question

Предположим, у вас есть один массив a[]=1,2,4,6 и второй массив b[]=3,5,7. Объединенный результат должен иметь все значения, т. Е. c[]=1,2,3,4,5,6,7. Объединение должно быть сделано без использования функций из <string.h>.

Answer 1

Я не скомпилировал и не протестировал следующий код, но я достаточно уверен. Я предполагаю, что оба входных массива уже отсортированы. Для достижения этой общей цели предстоит еще много работы, а не решение только для этого примера. Без сомнения, две фазы, которые я идентифицирую, могут быть объединены, но, возможно, их будет сложнее прочитать и проверить;

void merge_example()
{
    int a[] = {1,2,4,6};
    int b[] = {3,5,7};
    int c[100];     // fixme - production code would need a robust way
                    //  to ensure c[] always big enough
    int nbr_a = sizeof(a)/sizeof(a[0]);
    int nbr_b = sizeof(b)/sizeof(b[0]);
    int i=0, j=0, k=0;

    // Phase 1) 2 input arrays not exhausted
    while( i<nbr_a && j<nbr_b )
    {
        if( a[i] <= b[j] )
            c[k++] = a[i++];
        else
            c[k++] = b[j++];
    }

    // Phase 2) 1 input array not exhausted
    while( i < nbr_a )
        c[k++] = a[i++];
    while( j < nbr_b )
        c[k++] = b[j++];
}

Answer 2

Я учусь у них в данный момент, так что не принимайте это как идеальное решение, но, возможно, вы можете получить некоторые идеи из того, что я сделал, чтобы решить вашу собственную проблему.

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

int compare (const void * first, const void * second){
    return  *(int*)first - *(int*)second ;
}

int main(){
    int a[] = {1,2,4,6};
    int b[] = {3,5,7};
    size_t sizeA =sizeof(a)/sizeof(a[0]);
    size_t sizeB = sizeof(b)/sizeof(b[0]); 
    size_t sizeC = sizeA + sizeB; 
    /*allocate new array of sufficient size*/
    int *c = malloc(sizeof(int)*sizeC);
    unsigned i;
    /*copy elements from a into c*/
    for(i = 0; i<sizeA; ++i){
        c[i] = a[i];
    } 
    /*copy elements from b into c*/
    for(i = 0; i < sizeB; ++i){
        c[sizeA+i] = b[i];
    }
    printf("array unsorted:\n");
    for(i = 0; i < sizeC; ++i){
        printf("%d: %d\n", i, c[i]);
    }
    /*sort array from smallest to highest value*/
    qsort(c, sizeC, sizeof(int), compare);
    printf("array sorted:\n");
    for(i = 0; i < sizeC; ++i){
        printf("%d: %d\n", i, c[i]);
    }
    return 0;
}

Answer 3

это просто простая модификация ответов Билла, которая принимает n размерного массива:

    int main(void)
    {
        int m,n;
        int c[100];    
        printf("Enter Size of first Array: \n");
        scanf("%d",&m);
        printf("Enter Size of Second Array: \n");
        scanf("%d",&n);

        int a[m],b[n]; //Declaring array a and b with its size m and n accordingly

        int myval=m+n; //Size of the new array

        for(int i=0;i<m;i++){
            printf("Enter value for first[%d]:",i); 
            scanf("%d",&a[i]);
        }

        for(int i=0;i<m;i++){
            printf("Enter value for Second[%d]:",i);    
            scanf("%d",&b[i]);
        }

        int nbr_a = sizeof(a)/sizeof(a[0]); //this gives the actual size of an array
        int nbr_b = sizeof(b)/sizeof(b[0]);
        int i=0, j=0, k=0;

        // Phase 1) 2 input arrays not exhausted
        while( i<nbr_a && j<nbr_b )
        {
            if( a[i] <= b[j] )
                c[k++] = a[i++];
            else
                c[k++] = b[j++];
        }

        // Phase 2) 1 input array not exhausted
        while( i < nbr_a )
            c[k++] = a[i++];
        while( j < nbr_b )
            c[k++] = b[j++];

        for(i=0;i<myval;i++){
            printf("c[%d]:%d\n",i,c[i] );
        }
    }

Answer 4

Слияние 2 несортированных целочисленных массивов:

void main()
{
    clrscr();
    int A[10],B[10],C[26],a,b,n1,n2;
    cout<<"\n enter limit for array1     ";
    cin>>n1;
    cout<<"\n enter limit for array2     ";
    cin>>n2;
    a=0;b=0;int i=0;
    clrscr();
    while(1)
    {
        if(a<n1)
        {
            cout<<"\n enter element "<<a+1<<"for array1   ";
            cin>>A[a];
            clrscr();
            a++;
        }
        if(b<n2)
        {
            cout<<"\n enter element "<<b+1<<"for array2  ";
            cin>>B[b]; clrscr();
            b++;
        }
        if(a==n1&&b==n2)
            break;
    }
    a=0;b=0;
    cout<<"\n array merged";
    while(1)
    {
        if(a<n1)
        {
            C[a]=A[a];
            a++;
        }
        if(a>=n1&&b<n2)
        {
            C[a]=B[b];
            a++;b++;
        }
        if(a==(n1+n2))
        {
            if(i<(n1+n2))
            {
                cout<<endl<<C[i];
                i++;
            }
            else
                break;
        }
    }
    getch();// \m/
}

Answer 5

void merge(int *input1, size_t sz1, 
           int *input2, size_t sz2,
           int *output, size_t sz3) {
    int i = 0;
    int index1 = 0, index2 = 0;

    while (i < sz3 && index1 < sz1 && index2 < sz2)
        if (input1[index1] <= input2[index2])
            output[i++] = input1[index1++];
        else
            output[i++] = input2[index2++];

    if (index1 < sz1)
        for (; i < sz3 && index1 < sz1; ++i, ++index1)
            output[i] = input1[index1];
    else if (index2 < sz2)
        for (; i < sz3 && index2 < sz2; ++i, ++index2)
            output[i] = input2[index2];
}

который вы используете таким образом:

#define TAB_SIZE(x) (sizeof(x)/sizeof(*(x)))

int tab1[] = { 1, 2, 4, 6 };
int tab2[] = { 3, 5, 7 };

int tabMerged[TAB_SIZE(tab1)+TAB_SIZE(tab2)];
merge(tab1, TAB_SIZE(tab1), tab2, TAB_SIZE(tab2), tabMerged, TAB_SIZE(tabMerged));

Answer 6

В случае сортировки двух данных массивов:

while (true):
{
    if (a[i] < b[j])
    {
        c[k] = a[i];
        i++;
    } else {
        c[k] = b[j]
        j++
    }
    k++
}

i, j, k - индексы и начинаются с нуля. Имейте в виду, этот код не проверяет длину массива. Также вам нужно будет разбить его, когда вы достигнете конца обоих массивов. Но с этим легко иметь дело.

Если массивы предварительно не отсортированы, вы можете легко объединить их и вызвать для них функцию поиска, такую ​​как BubbleSort или QuickSort. Гугл те.