Partage
  • Partager sur Facebook
  • Partager sur Twitter

Tri de tableau

juste 1 explication clair

Sujet résolu
    1 mars 2021 à 22:06:41

    Bonjour, je suis sur le dernier exercice de tableau donner par Mathieu Nebra, le tri par ordre croissant, je l'ai réussi mais je suis pas très fier vu que j'ai chercher sur internet mais j'ai pas vraiment compris l'algorithme de la boucle for qui tri le petit nombre au plus grand.

    j'essaye de comprendre mais c'est vraiment pas très clair  ...

    Une gentille âme pourrais prendre son temp à m'expliquer ? j'ai vraiment du mal en algo :/ Merci d'avance

    ps : la je vous met juste la fonction .h  inclus dans le fichier main.c

    int tableau1[]; \\variable global
    
    void triMINsuccessif(int tableau[], int tailletableau)
    {
    
    
    int i = 0; int d = 0;  int tampon = 0;
    
    {
    
        for(d = 0; d < tailletableau; d++)
        {
    
        for(i = d; i < tailletableau; i++)
        {
    
        if (tableau [i] <= tableau [d])
        {
            tampon = tableau[d];
            tableau[d] = tableau [i];
            tableau[i] = tampon;
        }
    }
    }
        for(i=0; i < tailletableau; i++)
        {
            printf("tableau ordre croissant: %d \n\n", tableau[i]);
        }
        return 0;
    }
    }



    -
    Edité par SkellxPlayer 1 mars 2021 à 22:19:25

    • Partager sur Facebook
    • Partager sur Twitter
      1 mars 2021 à 22:13:14

      Bonjour, Merci de retirer toutes les lettres en capitales de votre titre.

      Majuscules abusives

      L'écriture en majuscules est considérée comme une parole criée et diminue autant la lisibilité du texte que sa compréhension. Les majuscules abusives sont donc interdites aussi bien dans les titres que dans les messages.

      La modération.

      Liens conseillés

      -
      Edité par AbcAbc6 1 mars 2021 à 22:13:44

      • Partager sur Facebook
      • Partager sur Twitter
        1 mars 2021 à 22:19:34

        Bonjour ! Fais afficher le tableau (avec des 'printf') à chaque étape. Tu le verras se mettre en ordre progressivement et tu devrais comprendre ce qui se passe.
        • Partager sur Facebook
        • Partager sur Twitter
          2 mars 2021 à 2:19:05

          Je suis d'accord avec la suggestion de robun.
          Je te suggère d'afficher tout le tableau à la fin (en dehors) de la boucle intérieure.
          Tu pourrais trier un très petit tableau pour commencer, disons 3 ou 4 entrées.
          Fais un essai en mettant les nombres en ordre inverse au départ. Tu verras, c'est amusant de voir la progression. :)
          Dans ton if, tu mets <= ...
          Ça ne sert à rien d'échanger si les valeurs sont égales. Mets seulement <
          Tu dis que tu veux comprendre l'algorithme? Tu pourrais l'améliorer.
          Juste avant le if, fait un printf des indices d et i
          Si tu part ta boucle intérieure avec i=d, tu vas forcément comparer un élément avec lui-même. Commences avec i=d+1
          Maintenant si d est rendu à tailleTableau-1 (la dernière valeur de ton for)
          Et que tu fais ensuite i=d+1, i vaudra tailleTableau. Donc tu fais une boucle inutile.
          Il faut donc faire d<tailleTableau-1
          En passant, ce tri s'appelle un "tri par sélection".
          Si tu es intéressé à faire les tests et les modifications, il y a moyen de réduire le nombre des échanges.
          • Partager sur Facebook
          • Partager sur Twitter

          Le Tout est souvent plus grand que la somme de ses parties.

            7 mars 2021 à 17:35:13

            bonjour, alors si j'ai bien compris lorsque l'indice du tableau i est inférieur au précédent indice il prend la place du chiffre ? sa fait 2j j'essaie de comprendre mais c'est vraiment pas évident ...je vous fait part de ce que j'ai fait :

            void triMINsuccessif(int tableau[], int tailletableau)
            {
            
            
            int i = 0; int d = 0;  int tampon = 0;
            
            {
            
                for(d = 0; d < tailletableau - 1; d++)
                {
            printf("étape 1, tableau : %d\n\n",tableau[d]);
            printf("étape 1 indice i = %d\n\n",i);
            printf("étape 1 indice d = %d\n\n",d);
            
                for(i = d ; i < tailletableau; i++)
                {
            printf("étape 2, tableau : %d\n\n",tableau[i]);
            printf("étape 2, indice i = %d\n\n",i);
            printf("étape 2, indice d = %d\n\n",d);
            
                if (tableau [i] < tableau [d])
                {
                    tampon = tableau[d];
                    tableau[d] = tableau [i];
                    tableau[i] = tampon;
                }
            
            printf(" étape 3 , tableau : %d\n\n",tableau[i]);
            printf("étape 3 indice i = %d\n\n",i);
            printf("étape 3 indice d = %d\n\n",d);
            
            }
            printf("étape 4, tableau : %d\n\n",tableau[i]);
            printf("étape 4 indice i = %d\n\n",i);
            printf("étape 4 indice d = %d\n\n",d);
            }
            printf("étape 5 tableau : %d\n\n",tableau[i]);
            printf("étape 5 indice i = %d\n\n",i);
            printf("étape 5 indice d = %d\n\n",d);
            
                for(i=0; i < tailletableau; i++)
                {
                    printf("tableau ordre croissant: %d \n\n", tableau[i]);
                }
                return 0;
            }
            }





            -
            Edité par SkellxPlayer 7 mars 2021 à 17:38:51

            • Partager sur Facebook
            • Partager sur Twitter
              7 mars 2021 à 18:01:23

              tTu vas te noyer dans tes printf(). Enlèves les.
              Tu ne peux pas faire de printf de i en dehors de la boucle sur i, ça ne fait aucun sens.
              Commence par faire un printf entre le for sur i et le if.
              Ça pourrait ressembler à ceci:
              printf("tableau[%d]=%d, tableau[%d]=%d\n", d, tableau[d], i, tableau[i]);
              Tu devrais voir ce que tu vas comparer dans le if et pourquoi je t'ai demandé de commencer avec i=d+1
              • Partager sur Facebook
              • Partager sur Twitter

              Le Tout est souvent plus grand que la somme de ses parties.

                7 mars 2021 à 20:36:27

                Voici comment je fais pour savoir ce qui se passe. J'ai repris le programme du premier message en ré-indentant, virant le « return 0 » inutile (warning signalé par le compilateur) et en ajoutant des 'printf' permettant de tout détailler pas à pas. J'en ai profité pour écrire une fonction d'affichage sur une seule ligne.

                #include <stdio.h>
                
                void afficheTableau(int tableau[], int tailletableau)
                {
                    int i;
                    printf("{%d", tableau[0]);
                    for(i = 1 ; i < tailletableau; i++)
                    {
                        printf(", %d", tableau[i]);
                    }
                    printf("}\n");
                }
                
                void triMINsuccessif(int tableau[], int tailletableau)
                {
                    int i = 0; int d = 0; int tampon = 0;
                    for(d = 0; d < tailletableau; d++)
                    {
                        printf("\nEtape %d : ", d);
                        afficheTableau(tableau, tailletableau);
                        for(i = d; i < tailletableau; i++)
                        {
                            printf("\tComparaison %d et %d\n ", tableau[d], tableau[i]);
                            if (tableau [i] <= tableau [d])
                            {
                                tampon = tableau[d];
                                tableau[d] = tableau [i];
                                tableau[i] = tampon;
                                printf("\t\téchange --> ");
                                afficheTableau(tableau, tailletableau);
                            }
                        }
                    }
                    for(i=0; i < tailletableau; i++)
                    {
                        printf("tableau ordre croissant: %d \n\n", tableau[i]);
                    }
                }
                
                int main(void)
                {
                    int tableau[] = {19, -5, 22, 0, -7, -5};
                    triMINsuccessif(tableau, 6);
                }

                Résultat :

                Etape 0 : {19, -5, 22, 0, -7, -5}
                        Comparaison 19 et 19
                                échange --> {19, -5, 22, 0, -7, -5}
                        Comparaison 19 et -5
                                échange --> {-5, 19, 22, 0, -7, -5}
                        Comparaison -5 et 22
                        Comparaison -5 et 0
                        Comparaison -5 et -7
                                échange --> {-7, 19, 22, 0, -5, -5}
                        Comparaison -7 et -5
                 
                Etape 1 : {-7, 19, 22, 0, -5, -5}
                        Comparaison 19 et 19
                                échange --> {-7, 19, 22, 0, -5, -5}
                        Comparaison 19 et 22
                        Comparaison 19 et 0
                                échange --> {-7, 0, 22, 19, -5, -5}
                        Comparaison 0 et -5
                                échange --> {-7, -5, 22, 19, 0, -5}
                        Comparaison -5 et -5
                                échange --> {-7, -5, 22, 19, 0, -5}
                
                Etape 2 : {-7, -5, 22, 19, 0, -5}
                        Comparaison 22 et 22
                                échange --> {-7, -5, 22, 19, 0, -5}
                        Comparaison 22 et 19
                                échange --> {-7, -5, 19, 22, 0, -5}
                        Comparaison 19 et 0
                                échange --> {-7, -5, 0, 22, 19, -5}
                        Comparaison 0 et -5
                                échange --> {-7, -5, -5, 22, 19, 0}
                
                Etape 3 : {-7, -5, -5, 22, 19, 0}
                        Comparaison 22 et 22
                                échange --> {-7, -5, -5, 22, 19, 0}
                        Comparaison 22 et 19
                                échange --> {-7, -5, -5, 19, 22, 0}
                        Comparaison 19 et 0
                                échange --> {-7, -5, -5, 0, 22, 19}
                
                Etape 4 : {-7, -5, -5, 0, 22, 19}
                        Comparaison 22 et 22
                                échange --> {-7, -5, -5, 0, 22, 19}
                        Comparaison 22 et 19
                                échange --> {-7, -5, -5, 0, 19, 22}
                
                Etape 5 : {-7, -5, -5, 0, 19, 22}
                        Comparaison 22 et 22
                                échange --> {-7, -5, -5, 0, 19, 22}
                tableau ordre croissant: -7 
                
                tableau ordre croissant: -5 
                
                tableau ordre croissant: -5 
                
                tableau ordre croissant: 0 
                
                tableau ordre croissant: 19 
                
                tableau ordre croissant: 22 
                

                Et là on comprend le principe, non ? (Normalement, on voit aussi qu'on peut optimiser.) (On voit aussi que ce n'est pas l'algorithme illustré par rouloude.)

                C'est ce que j'appelle la méthode bourrin : plutôt que de perdre son temps à chercher en vain un truc intelligent à faire, on fait un truc bête. A priori ça va être long (ajouter tous ces 'printf' !) mais c'est moins long que de trouver un truc intelligent. :)

                -
                Edité par robun 7 mars 2021 à 20:51:16

                • Partager sur Facebook
                • Partager sur Twitter
                  8 mars 2021 à 2:09:06

                  @robun:
                  Je vote +1
                  Quand le tableau n'est pas trop long, c'est une très  bonne idée que de tout mettre sur une seule ligne.
                  On pourrait faire la même chose à la toute fin.
                  On pourrait compter le nombre de comparaisons et d'échange, mais SkellxPlayer n'est peut-être pas encore prêt pour cela ...
                  • Partager sur Facebook
                  • Partager sur Twitter

                  Le Tout est souvent plus grand que la somme de ses parties.

                    8 mars 2021 à 3:52:10 - Message modéré pour le motif suivant : Merci de créer votre propre sujet


                      8 mars 2021 à 4:29:13 - Message modéré pour le motif suivant : Réponse à un message modéré


                      Le Tout est souvent plus grand que la somme de ses parties.

                        9 mars 2021 à 21:16:28

                        robun a écrit:

                        Merci Robun pour votre patience et vote gentillesse ainsi que à Pierolefou je vais me mettre au travail et appliqué ce que vous avez fait et expliqué.

                        et merci a rouloude pour l'explication en image !!! 



                        • Partager sur Facebook
                        • Partager sur Twitter

                        Tri de tableau

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