Langage C

Bonjour, j'ai une question
je ne sais pas comment faire.
j'ai un tableau d'éléments "int tab1" avec différentes valeur à l'intérieur croissante et un deuxième avec d'autre valeurs croissante "int tab2".
je souhaite combiner ces deux tableaux en un , tout en ayant les valeurs croissantes.
si quelqu'un peu m'expliqué et me donnée un exemple , je lui serai très reconnaissant.
merci

2 réponses

  1. Contributeur
    Bonjour,

    Tout d'abord, int tab1 n'est pas un tableau mais un simple entier.
    Le tableau est : int tab1[TAILLE1];

    Pour ta demande, il suffit de créer un tableau de taille suffisamment grande (TAILLE1 + TAILLE2). Et de le trier.

    Par exemple : int tab3[TAILLE1 + TAILLE2];
    puis, il suffira de faire :
    memcpy(tab3, tab1, sizeof tab1);
    memcpy(tab3+TAILLE1, tab2, sizeof tab2);

    Et après, un petit tri et le tour est joué.
    1. Modérateur
      Par exemple:
      #include <stdlib.h>
      #include <stdio.h>
      #include <string.h>
      #include <time.h>
      
      void usage(const char*progname)
      {
        fprintf(stderr, "usage %s, length1, length2\n", progname);
      }
      void no_alloc()
      {
        fprintf(stderr, "Memory allocation error\n");
      }
       
      void dump_array(int* tab, unsigned int len)
      {
        int i =0;
        for( ; i < len; i++)
          {
            printf("%d ", tab[i]);
            putchar('\n');
          }
      }
      
      int compint(int *a, int *b)
      {
        return ((int)*a - (int)*b);
      }
      
      int *merge_int_array( const int* tab1, unsigned int n1, const int* tab2, unsigned int n2)
      {
        int *result = malloc(n1+n2);
        //void *memcpy(void *dest, const void *src, size_t n);
        memcpy(result, tab1, n1 * sizeof(int));
        memcpy(result + n1, tab2, n2 * sizeof(int));
        /*void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); */
        qsort(result, n1 + n2, sizeof(int), compint);
        return result;
        
      }
      
      int main(int argc, char*argv[])
      {
        int i,n1, n2;
        int *tab1, *tab2, *merged_array;
        if (argc < 3)
          {
            usage(argv[0]);
            return EXIT_SUCCESS;
          }
        
        n1 = atoi(argv[1]);
        n2 = atoi(argv[2]);
        tab1 = malloc(n1 * sizeof(int));
        tab2 = malloc(n2 * sizeof(int));
        srand(time(NULL));
        if((tab1 == NULL) | (tab2 == NULL))
          {
            no_alloc();
            return EXIT_FAILURE;
          }
        for (i = 0; i< n1; i++)
          {
            tab1[i] = rand();
          }
        for (i = 0; i< n2; i++)
          {
            tab2[i] = rand();
          }
        printf("At line %d\n", __LINE__);
        printf("Dummping array1:\n");
        dump_array(tab1, n1);
        printf("Dummping array2:\n");
        dump_array(tab2,n2);
        merged_array = merge_int_array(tab1, n1, tab2, n2);
        printf("Dummping merged array:\n");
        dump_array(merged_array, n1 + n2);
        return EXIT_SUCCESS;
      }
      johand@osiris: ~/src/CCM/C $ ./merge_arrays 5 5
      At line 70
      Dummping array1:
      614374766 
      2043203106 
      90578780 
      1356121019 
      1081406063 
      Dummping array2:
      1617966626 
      734061849 
      1707533276 
      555258101 
      1624582305 
      Dummping merged array:
      90578780 
      555258101 
      614374766 
      734061849 
      1081406063 
      1356121019 
      1617966626 
      1624582305 
      1707533276 
      2043203106
      1. Contributeur
        Yen a qui ont de la chance ^^.
        return ((int)*a - (int)*b);
        Pourquoi caster un int en int ?

        Et enfin, atoi() est obsolète. Mais sinon, bon programme :-).
      2. Modérateur
        Comment voudrais-tu faire autrement? Le prototype de la fonction 'compar' 4-çme paramètre de qsort) attend en principe des pointeurs void* en argument.
        Pour comparer deux entiers tu est obligé de déréférencer les pointenrs avec en plus un cast vers int. Mais il est vrai que le cast est superflu. Mon prototye pour compint était à l'origine int(void*, void*). Mais cela ne change rien en principe au résultat du code objet.
        Sinon les résultats seront surprenants.
      3. Contributeur
        Pour comparer deux entiers tu est obligé de déréférencer les pointenrs avec en plus un cast vers int.
        Exact. Mais ici les arguments sont déjà déférencés en int* via le prototype.
        Enfin, c'était juste pour apporter des précisions sur le code. T'as fait le plus gros ;-)))
      4. #include <stdio.h>
        void ordonnerTableau(long tableau[], long tailleTableau);
        int main ()
        {
        int Na,Nb,chiffre,chiffre1,i,j,k,l,m,n;

        scanf("%d",&Na);
        int valeurA[Na];

        for(i=0;i<Na;i++)
        {
        scanf("%d",&chiffre);
        valeurA[i]=chiffre;
        }

        scanf("%d",&Nb);
        int valeurB[Nb];

        for(j=0;j<Nb;j++)
        {
        scanf("%d",&chiffre1);
        valeurB[j]=chiffre1;
        }

        int tableauFinal[Na+Nb];

        memcpy(tableauFinal, valeurA, sizeof valeurA);
        memcpy(tableauFinal+Na, valeurB, sizeof valeurB);
        int valeur=0;
        valeur=Na+Nb;
        ordonnerTableau(tableauFinal,valeur);

        for(m=0;m<valeur;m++)
        printf("%d ",tableauFinal[m]);
        return 0;
        }

        void ordonnerTableau(long tableau[], long tailleTableau)
        {
        long i,t,k=0;

        for(t = 1; t < tailleTableau; t++)
        {
        for(i=0; i < tailleTableau - 1; i++)
        {
        if(tableau[i] > tableau[i+1])
        {
        k= tableau[i] - tableau[i+1];
        tableau[i] -= k;
        tableau[i+1] += k;
        }
        }
        }
        }

        voici mon code mais celui-ci est trop lent
        désolé je suis simple débutant en programmation
        merci