Partage
  • Partager sur Facebook
  • Partager sur Twitter

Ordonner Tableau [TABLEAU EN C]

Tutoriel C de Mateo

    13 février 2017 à 9:44:11

    Illustration

    	6	3	44	11	22	8	33	2	5
    	^^^	^^^	^^^	^^^	^^^	^^^	^^^	^^^	^^^
    	3	6	11	22	8	33	2	5	44
    	^^^	^^^	^^^	^^^	^^^	^^^	^^^	^^^	 
    	3	6	11	8	22	2	5	33	44
    	 	 	^^^	^^^	^^^	^^^	^^^	 	 
    	3	6	8	11	2	5	22	33	44
    	 	^^^	^^^	^^^	^^^	^^^	 	 	 
    	3	6	8	2	5	11	22	33	44
    	 	 	^^^	^^^	^^^	 	 	 	 
    	3	6	2	5	8	11	22	33	44
    	 	^^^	^^^	^^^	 	 	 	 	 
    	3	2	5	6	8	11	22	33	44
    	^^^	^^^	^^^	 	 	 	 	 	 
    Résultat
    	2	3	5	6	8	11	22	33	44
    	


    Code :

    #include <stdio.h>
    
    void afficher(int t[], int n, int first, int last) {
    	for (int i=0; i<n; i++) {
    		printf("\t%d", t[i]);
    	}
    	printf("\n");
    	for (int i=0; i<n; i++) {
    		printf("\t%s", (first<=i) && (i<=last) ? "^^^" : " ");
    	}
    	printf("\n");
    }
    		
    void bubulle(int t[], int n)
    {
    	int first = 0, last = n-1;  // à trier : de first à last compris
    	while (first < last) {
    		afficher(t,n, first, last);
    		// recherche position du premier échange
    		int f = first;
    		while ( (f < last) && (t[f] < t[f+1])) {
    			f++;
    		}
    		if (f==last) break;
    
    		// échanges successifs
    		int l = f;                    // position du dernier échange
    		for(int i = f; i < last; i++) {
    			if (t[i] > t[i+1]) {
    				l = i;
    				int tmp = t[i];
    				t[i] = t[i+1];
    				t[i+1] = tmp;
    			}
    		}
    		
    		first = (f > 0) ? f-1 : 0;
    		last = l;
    	};	
    }
    
    int main()
    {
    	int t[] = { 6, 3, 44, 11 , 22, 8, 33 , 2 , 5, 44 };
    	 bubulle (t, 9);
    	 printf("Résultat\n");
    	 afficher(t, 9, -1, -1);
    	return 0;
    }


    "améliorer le tri à bulles", la semaine commence bien, tiens...

    Autre exemple

    	
    	1	2	3	6	5	7	4	8	9
    	^^^	^^^	^^^	^^^	^^^	^^^	^^^	^^^	^^^
    	1	2	3	5	6	4	7	8	9
    	 	 	^^^	^^^	^^^	^^^	 	 	 
    	1	2	3	5	4	6	7	8	9
    	 	 	 	^^^	^^^	 	 	 	 
    	1	2	3	4	5	6	7	8	9
    	 	 	^^^	^^^	 	 	 	 	 
    Résultat
    	1	2	3	4	5	6	7	8	9
    



    -
    Edité par michelbillaud 13 février 2017 à 9:53:06

    • Partager sur Facebook
    • Partager sur Twitter
      25 mars 2017 à 11:23:45

      Bonjour

      Je suis débutant en langage C et suis le cours avec attention

      J'ai vu et essayé le code fourni par ayoubanane.

      Ce programme boucle sans arrêt et ne sort jamais

      Je l'ai donc modifié

      #include <stdio.h>
      #include <stdlib.h>
      void ordonnerTableau(int tableau[], int tailleTableau);
      void afficheNouveauTableau(int tableau[], int tailleTableau);
      
      int main(int argc, char *argv[])
      {
          int tableau[19] = {7,4,1,8,5,2,9,6,3,19,18,17,16,15,14,10,12,13,11};
          afficheNouveauTableau(tableau,19);
          ordonnerTableau(tableau,19);
          afficheNouveauTableau(tableau,19);
          return 0;
      }
      void afficheNouveauTableau(int tableau[], int tailleTableau)
      {
          int k;
      
          for (k = 0 ; k < tailleTableau ; k++)
          {
              printf("%d-", tableau[k]);
          }
          printf("\n");
      
      }
      void ordonnerTableau(int tableau[], int tailleTableau)
      {
          int i,temp,erreur;
          do
          {
              erreur=0;
              for(i=0;i<tailleTableau-1;i++)
                  {
                      if(tableau[i]>tableau[i+1])
                      {
                          erreur=1;
                          temp=tableau[i];
                          tableau[i]=tableau[i+1];
                          tableau[i+1]=temp;
                          afficheNouveauTableau(tableau,19);
      
                      }
      
                  }
              }
          while (erreur!=0);
      }
      

      Ce code fonctionne bien et je suis très content à mon humble niveau

      Claude Azoulai

      • Partager sur Facebook
      • Partager sur Twitter
        12 mai 2017 à 1:18:04

        Pour ceux (les néophytes dans mon genre) qui s'interrogent ou cherchent des pistes relativement à ce programme, voici ce que j'ai réussi à faire. 

        void ordonnertableau(int tableau[])

        int i; 

        int j,z;

        for (i = 0; i<4; i++)

        for (j =i; j < 4; j ++)

        {

        if (tableau[i] > tableau [j])

        {

        z = tableau [i];

        tableau[i] = tableau[j];

        tableau[j] = z; 

        }

        }

        printf("\t %d", tableau[i]);

        }

        }

        int main(int argc, char *argv[])

        {

        int i;

            int tableau [4] = {115,42,3,47};

           printf("la somme du tableau est %d \n",sommetableau(tableau));

           printf( " la moyenne du tableau est : %lf \n", moyennetableau(tableau)); 

           printf(" voici un tableau mieux ordonne : \n" ); 

           ordonnertableau(tableau);

            return 0;

        }

        Le choix d'un tableau à 4 dimensions m'a permis de mieux comprendre l'utilisation de la mémoire par l'ordinateur et je vous conseille également de vous munir d'une feuille et d'un crayon afin de vous représenter au mieux et de manière schématique l'acheminement entrepris par le compilateur. 

        Bon courage à tous ! 

        MAK. 

        -
        Edité par Michel-AngeKounga 12 mai 2017 à 1:18:57

        • Partager sur Facebook
        • Partager sur Twitter
          12 mai 2017 à 9:40:52

          Ton programme ne fonctionne que pour les tableaux qui ont exactement 4 éléments, ce qui restreint grandement son utilité.

          Tu devrais passer la taille du tableau en paramètre de la fonction.

          Pendant qu'on y est, ta fonction sert à ordonner, elle ne devrait donc pas afficher. Si tu ecrivais une fonction afficher(), tu pourrais l'employer avant et après le tri.

           EDIT pour être rigoureux dans le vocabulaire - ce qui est mieux pour avoir des idées précises - ce n'est pas un tableau à 4 dimensions, mais à une dimension. C'est sa taille qui est 4.

          -
          Edité par michelbillaud 12 mai 2017 à 9:49:27

          • Partager sur Facebook
          • Partager sur Twitter
            16 juin 2017 à 20:42:22

            Sinon,

            y'a le quick sort qui est déjà implanté en c avec la fonction qsort (qui est un tri optimal)

            (si je suis pas dans le sujet, dites-le moi et je sors...)

            • Partager sur Facebook
            • Partager sur Twitter
            Software is like sex: it's better when it's free - Linus Torvald
              19 juin 2017 à 21:37:19

              Voila mon code (normalement sa marche nickel) . Vous en pensez quoi ? J'ai utiliser l'allocation dynamique mais c'est pas forcement obliger il suffit de définir manuellement la taille du tableaux au début de la fonction.
              int compteur , i , a , *tableau_final = malloc(sizeof(int) * tailleTableau); // initialisation des variable et creation d un tableau de taille egal a celui que  l utilisateur va passer a la fonction
                  if (tableau_final != NULL) //verification si l allocation memoire a marcher
                  {
                      for (i = 0 ; i < tailleTableau ; i++)
                      {
                          compteur = tailleTableau - 1;
              
                              for (a = 0 ; a < tailleTableau ; a++)
                              {
                                  compteur = (tableau[i] < tableau[a]) ? compteur - 1:compteur;
                              }
                          tableau_final[compteur] = tableau[i]; // compteur  = position du nombre dans le nouvelle ordre du tableau ; tableau[i] = valeur a classer
                      }
                      for (i = 0 ; i < tailleTableau ; i++) // incrémentation des valeur du tableau classer dans celui pas classer
                      {
                          tableau[i] = tableau_final[i];
                      }
                  free(tableau_final); // libere l espace memoire utiliser pour la creation du second tableau
                  }
                  else
                      printf("Erreur impossible d'allouer %d octes de memoire\n",sizeof(int) * tailleTableau);
              }
              • Partager sur Facebook
              • Partager sur Twitter
                20 juin 2017 à 0:13:38

                Bonjour,

                Il n'y a que des commentaires inutiles, et aucun commentaire qui explique le principe du tri.

                Et que faut-il comprendre par "sa marche nickel"? Ca a été vaguement testé avec un petit exemple et basta? Ce qui est sûr, c'est que les tests ont été négligés.

                • Partager sur Facebook
                • Partager sur Twitter
                  20 juin 2017 à 2:55:29

                  Pourquoi tu dit sa ? Si tu prend un tableau peut importe la taille normalement pour moi sa marche . Merci d'argumenter de façon constructif sur le "vaguement teste" et sur le code . Comme se qui pourrait être amélioré par exemple.
                  • Partager sur Facebook
                  • Partager sur Twitter
                    20 juin 2017 à 7:46:24

                    Parce que ca se voit que ca ne marche pas.

                    As tu essayé avec un tableau qui contient 2 fois la même valeur, par exemple   2 1 2 ?

                    EDIT : voila une version de ton programme de tri "nickel". L'idée est visiblement de determiner l'emplacement que prendrait un élément, en comptant combien sont plus petits ou plus grand. Pas bête. Sauf que ça ne marche pas bien. Donc ça ne marche pas.

                    J'ai ajouté de quoi faire des tests proprement. Les tests, c'est pas un truc à traiter par dessus la jambe, alors autant écrire quelques fonctions pour le faire confortablement.

                    // programme de tri. Ne marche pas si il y a des éléments répétés.
                    
                    #include <stdio.h>
                    
                    void tri_nickel(int t[], int n)
                    {
                    	int temp[n];   // un tableau temporaire, pas final
                    	for (int i = 0; i < n; i++) {
                    		// idée : on regarde combien d'éléments sont plus
                    		// petits que t[i]
                    		int nb = 0;   
                    		for (int j = 0; j < n ; j++) {
                    			if (t[j] < t[i]) nb++;
                    		}
                    		// et ça nous dit où mettre t[i]
                    		// - enfin, si ça marchait
                    		temp[nb] = t[i];
                    	}
                    	// on ramène les données
                    	for (int i = 0; i < n ; i++)
                    		t[i] = temp[i];
                    }
                    
                    void afficher (char texte[], int t[], int n) {
                    	printf("- %s : ", texte);
                    	for (int i = 0; i < n ; i++) 
                    		printf("%d ", t[i]);
                    	printf("\n");
                    }
                    
                    void tester_avec(char message[], int t[], int n) 
                    {
                    	printf("* Test %s\n", message);
                    	afficher("avant", t,n);
                    	tri_nickel(t,n);
                    	afficher("apres", t,n);
                    }
                    
                    int main(void)
                    {
                    	int t1[] = {20, 30, 10};
                    	tester_avec("ok", t1, 3);
                    	
                    	int t2[] = {20, 10, 20};
                    	tester_avec("bug repetition", t2, 3);
                    	
                    	int t3[] = {10, 10};
                    	tester_avec("bug minimaliste", t3, 2);
                    	
                    	return 0;
                    }

                    Résultat :

                    * Test ok
                    - avant : 20 30 10 
                    - apres : 10 20 30 
                    * Test bug
                    - avant : 20 10 20 
                    - apres : 10 20 -1764686434    # houla
                    * Test bug minimal
                    - avant : 10 10 
                    - apres : 10 0                 # houlala
                    
                    




                    -
                    Edité par michelbillaud 20 juin 2017 à 9:54:10

                    • Partager sur Facebook
                    • Partager sur Twitter
                      20 juin 2017 à 10:57:13

                      michelbillaud a écrit:

                      EDIT : voila une version de ton programme de tri "nickel". L'idée est visiblement de determiner l'emplacement que prendrait un élément, en comptant combien sont plus petits ou plus grand.

                      Bonjour

                      Merci d'avoir expliqué le principe.
                      TheoGaillard1 c'est cela que tu aurais dû mettre en commentaire plutôt que la paraphrase inutile et encombrante telle que // libere l espace memoire utiliser pour la creation du second tableau

                      • Partager sur Facebook
                      • Partager sur Twitter
                        20 juin 2017 à 11:45:15

                        [paraphrase inutile et encombrante]

                        C'est un problème lié aux exemples qu'on montre aux débutants. Les commentaires y sont essentiellement pour paraphraser les mécanismes et tournures courantes du langage. Exemples

                        x ++;                       // on ajoute 1 à x;
                        for (int i=0; i<10; i++) {  // i va de 0 à 9.
                        ....
                        }

                        C'est ok dans le contexte "prof qui explique à un débutant qui connait rien".

                        Alors, monkey see, monkey do.

                        Maintenant, le vrai rôle du commentaire, c'est pas ça. C'est "programmeur qui explique à un autre programmeur" (*)  Il faut que ça explique quelque chose qui a besoin dêtre expliqué, sinon c'est du bavardage. Si on lui dit que free(tableau), ça libère le tableau, il va avoir légèrement l'impression qu'on le prend pour un con. Faut pas lui faire perdre son temps.

                         (*) qui doit modifier/corriger le programme, boulot qu'on ne confie pas à un débutant qui ne connait même pas les bases du langage (normalement).

                        -
                        Edité par michelbillaud 20 juin 2017 à 13:33:41

                        • Partager sur Facebook
                        • Partager sur Twitter
                          21 juin 2017 à 18:54:00

                          si la taille du tableau est doublée à chanque fois qu'il est plein, quel est le nombre de copies necessaire pour insérer n=2 exp m?
                          • Partager sur Facebook
                          • Partager sur Twitter
                          Prince M
                            22 juin 2017 à 7:17:18

                            Pour caser 2^m  élements il faut à peu près m-1  réallocations (en partant d'une taille 1 pour simplifier)

                            à la premiere il y aura 1 element à recopier, 2 à la seconde, 4 à la troisieme etc, donc 2^0 + 2^1 + ... 2^(m-1)

                            ce qui fait 2^m - 1

                            Si on rapporte ça au nombre d'éléments (2^m), une valeur du tableau sera copiée 1 fois en moyenne.

                            -
                            Edité par michelbillaud 22 juin 2017 à 7:32:20

                            • Partager sur Facebook
                            • Partager sur Twitter
                              1 janvier 2019 à 22:08:54

                              bonjour  tous je sais que ce sujet date depuis un certain temps mais il y a quelque chose que je ne comprends pas donc je me permets de le déterrer.j'ai vu plus haut que dans le deuxième boucle que l'on crée dans la fonction "ordonnerTableau" qu'il fallait mettre la variable    tailleTableau - i et je n'arrive pas a comprendre donc a la place de recopier bêtement je vous demande de l'aide merci.

                              void ordonnerTab(int tableau [], int tailleTableau)

                              {

                                      int i, e;

                                  for(i = 0; i < tailleTableau; i++)

                                  {

                                      for (e = 1; e < tailleTableau - i; e++)

                                      {

                                          if(tableau[i] < tableau[e])

                                          {

                                          }

                                      }

                                  }

                              }

                              • Partager sur Facebook
                              • Partager sur Twitter
                                2 janvier 2019 à 8:14:22

                                Illisible. Utiliser le bouton  </> pour poster du code.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  3 janvier 2019 à 11:28:58

                                  désolé mon code était illisible. j'aimerai savoir ce qui ne va pas dans ma fonction ordonner Tableau merci d'avance

                                  void ordonnerTab(int tableau[], int tailleTableau)
                                  {
                                      int i, c, stock;
                                      for(i = 0; i < tailleTableau; i++)
                                      {
                                          for(c = i + 1; c < tailleTableau; c++)
                                          {
                                              if(tableau[i] > tableau[c])
                                              {
                                              stock = tableau[i];
                                              tableau[i] = tableau[c];
                                              tableau[c] = stock;
                                              }
                                              if (tableau[c] >tableau[i])
                                              {
                                                  stock = tableau[c];
                                                  tableau[c] = tableau[i];
                                                  tableau[i] = stock;
                                              }
                                          }
                                      }
                                      
                                  }



                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    3 janvier 2019 à 11:42:21

                                    Hello,

                                    En imaginant que tableau[i] soit plus grand que tableau[c] (ligne 8), tu vas inverser tableau[i] et tableau[c]. Et donc, arrivé ligne 14, tableau[c] sera plus grand que tableau[i], et tu vas remettre les valeurs à leur position de départ.

                                    -
                                    Edité par edgarjacobs 3 janvier 2019 à 11:44:20

                                    • Partager sur Facebook
                                    • Partager sur Twitter

                                    Aucune aide ne sera donnée par mp

                                      17 juin 2019 à 22:50:06

                                      void OrdonnerTableau(int tableau[], int TailleTableau)
                                      {
                                          int i=0,j=0,temp;
                                          for(i=0; i<TailleTableau; i++)
                                          {
                                              for(j=0; j<TailleTableau; j++)
                                              {
                                                  if (tableau[i]<tableau[j])
                                                  {
                                                      temp=tableau[i];
                                                      tableau[i]=tableau[j];
                                                      tableau[j]=temp;
                                                  }
                                              }
                                          }
                                          for(i=0; i<TailleTableau; i++)
                                              {
                                                  printf("%4d ",tableau[i]);
                                              }
                                      }
                                      • je trouve pas de soulutions plus optimale aidez moi svp
                                      • ps: ça marche mais je veux savoir si je peux fair mieux 

                                      -
                                      Edité par AnisKadri3 17 juin 2019 à 22:57:58

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        18 juin 2019 à 10:25:15

                                        * Une petite chose :

                                        Si la fonction s'appelle OrdonnerTableau, son rôle est d'ordonner, et pas d'afficher.

                                        Donc enlever la boucle d'affichage.

                                        * Si il y a besoin d'afficher après avoir ordonné, appeller une fonction AfficherTableau après avoir appelé OrdonnerTableau. Chacun son boulot.

                                        Mais puisqu'on le demande, une optimisation (mineure) : la boucle sur j peut commencer à i+1. 

                                        * le tri à bulle, on ne l'optimise pas, on le jette. Il est foncièrement inefficace. Si on s'intéresse sérieusement au tri, on prend un meilleur algorithme. Mais à ce point de l'apprentissage de la programmation, ce n'est pas encore le moment de se prendre la tête avec ça.

                                        Un raisonnement simple (*) permet de voir que, quand on rentre dans la boucle sur j, les éléments d'indice 0 à i-1 sont déjà à leurs places définitives, il est donc inutile de les réordonner. Et il est également inutile de comparer tableau[i] avec lui même.

                                        (*) une récurrence, en fait

                                        -
                                        Edité par michelbillaud 18 juin 2019 à 10:29:29

                                        • Partager sur Facebook
                                        • Partager sur Twitter

                                        Ordonner Tableau [TABLEAU EN C]

                                        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                        • Editeur
                                        • Markdown