Forum Programmation.java comment trier des nombres?

Posté par  .
Étiquettes : aucune
0
1
fév.
2005
Bonjour tout le monde,
j'envisage de trier des entiers dans la mesure où ils sont compris entre 0 et 100 mais je ne sais pas où trouver des indices pour écrire ce code alors si vous avez une petite idée.
Que ce soit le nom d'une instruction ou d'une méthode de tri ce serait sympa...

Comment faire pour stocker en mémoire un chiffre afin qu'il soit comparer à un autre? En gros c'est ça mon problème

Merci de votre aide
  • # Mon préféré : le "tri par bulles"

    Posté par  . Évalué à 1.

    • [^] # Re: Mon préféré : le "tri par bulles"

      Posté par  (site web personnel) . Évalué à 2.

      il y a 4 methodes de tri, la seconde est le tri par insertion. J ai oublie les deux autres:

      http://www.cs.montana.edu/webworks/webworks-home/links/sorting.html(...)
      http://support.microsoft.com/?kbid=169617(...)
      http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html(...)

      chaque lien a plusieurs listes d algos.
      • [^] # Re: Mon préféré : le "tri par bulles"

        Posté par  (site web personnel) . Évalué à 1.

        On m'a toujours dit que le quicksort était plus rapide que le BubbleSort http://c2.com/cgi/wiki?QuickSort(...)

        D'après la même source voici les différents algos de tri: http://c2.com/cgi/wiki?SortingAlgorithms(...)
        • [^] # Re: Mon préféré : le "tri par bulles"

          Posté par  (site web personnel) . Évalué à 1.

          le mec ne cherches pas un truc rapide, mais un truc assez simple pour qu il puisse le comprendre te l implementer. Le tri bulle est donc le plus efficace pour lui, car le plus simple a expliquer.
          • [^] # Re: Mon préféré : le "tri par bulles"

            Posté par  . Évalué à 1.

            bein d'après mes vagues souvenirs de cours d'algo, j'ai eu plus facile à comprendre le tri pas insertion que le le bubble sort...
            par contre, le quick sort, c'est pas la même chose :D
          • [^] # Re: Mon préféré : le "tri par bulles"

            Posté par  . Évalué à 1.

            Et puis si y a moins de 100 nombres, il verra pas la différence. Ceci dit le tri par insertion est clairement le plus facile à comprendre, mais comprendre le quicksort peut resservir (c'est le même principe pour un algo de calcul de médiane, par exemple). Et puis c'est pas non plus la mer à boire (une histoire de pivot si je me souviens bien).
            Pour votre information, le quatrième c'est le tri par selection, mais je ne me souviens par contre pas en quoi il consiste.
          • [^] # pour la rapidité chapeau

            Posté par  . Évalué à 1.

            heu là je suis un peu gêné de vous dire ça mais en allant sur les liens que vous m'avez indiqué , y'a beaucoup de liens dde cassés et du coup j'ai rien compris je crois que le nom de la méthode à utiliser est " permuter.c" mais trouve pas d'explications à mon niveau de débutant

            bref, je comprens rien ça vous dérangerait pas d'expliquer plus en détail svp?

            Ps c'est un tableau d'entiers que je veux trier

            merci
            • [^] # Re: pour la rapidité chapeau

              Posté par  . Évalué à 2.

              Bon, un petit tri simple, le tri selection/permutation :

              Tu recherches le plus grand élément du tableau, et tu l'échanges avec le premier.
              Ensuite tu prend le second plus grand (dans le reste du tableau) et tu l'échanges avec le second, ...

              en pseudo code, ca doit donner quelque chose comme ça :

              pour début_non_trié de 1 à tailledutableau
                 indice_max <- début_non_trié

                //sélection du plus grand élément du tableau non trié
                pour x de début_non_trié à tailledutableau
                  si (tab[x] > tab[début_non_trié]) alors
                    indice_max<-x
                  fin si
                fin pour

                // échange de début_non_trié avec le max

                y <- tab[début_non_trié] // y variable temporaire
                tab[début_non_trié] <- tab[indice_max]
                tab[indice_max] <- y
              fin pour
            • [^] # Re: pour la rapidité chapeau

              Posté par  . Évalué à 2.

              C'est domage que tu n'aie pas dit quel language tu utilises mais bon.
              On va faire ca en C.

              Tout d'abors il y a plusieurs méthodes pour trier des éléments (qu'ils soient entiers ou non, il faut juste qu'ils soient ordonnés, pour des entier, l'ordre, c'est la valeur, mais si c'était des bananes ce serait leur poids par exemple)

              Tri à bulle cité plus haut consiste à remonter le plus petit élément au début du tableau. (ou le plus grand selon l'ordre que tu veux)

              soit un tableau :
              tab = [2|3|8|9|4|5|1]

              On cherche le plus petit à partir du début (tab[0] à tab[6]) : 1
              1 est à la postion 6.
              On l'échange avec 2 :

              tmp = tab[0];
              tab[0] = tab[6];
              tab[6] = tmp;

              on obtient tab == [1|3|8|9|4|5|2]

              Après on recherche le plus petit à partir du second élément (tab[1] à tab[6]) : 2
              on l'échange avec 3
              on obtient tab == [1|2|8|9|4|5|3]

              tu continue : tab devient à le suite :

              [1|2|3|9|4|5|8]
              [1|2|3|4|9|5|8]
              [1|2|3|4|5|9|8]
              [1|2|3|4|5|8|9]

              voilà.

              Ca c'est la présentation de l'algo, maintenant il faut le présenter sous forme
              de language informatique.
              Comme tu t'en doute, la procédure est identique pour tout les éléments,
              il faut donc utiliser une boucle, qui va réexécuter le même bout de code à
              quelques variations près (ici la recher et l'echange de élément).

              Ceci nécessite d'ajouter des variables de boucles, qui se modifirons
              au fur et à mesure de l'exécution.

              int depart = 0 // premier élément à partir duquel on cherche
              int dernierPlusPetit // élément le plus petit trouvé lors de la recheche.
              int indiceDuDernierPlusPetit // position du denier plus petit trouvé.
              int tmp // variable temporaire.

              // on s'arrête à TAILLE_TAB - 2 car le tableau sera trié à la fin du tri de
              // l'avant dernière variable : on ne tri pas une valeur toute seule
              pour i de 0 à TAILLE_TAB - 2 faire

              // recherche du plus petit élément
              // on commence par initialiser les variables, si besoin
              dernierPlusPetit = tab[depart + 1]
              indiceDuDernierPlusPetit = depart + 1
              pour j de depart à TAILLE_TAB - 1
              // on regarde les éléments un a un
              si (dernierPlusPetit < tab[j] ) alors
              // si on en trouve un plus petit que le dernier petit connu,
              // c'est le nouveau dernier plus petit
              dernierPlusPetit = tab[j]
              indiceDuDernierPlusPetit = j
              finsi

              // On a le dernier plus petit, reste à le mettre à sa place.
              tmp = tab[depart]
              tab[depart] = tab[indiceDuDernierPlusPetit]
              tab[indiceDuDernierPlusPetit] = tmp

              finpour

              finpour

              Voilà.

              Si tu est débutant et si tu as vraiment du mal à comprendre ca je te
              conseille de te trouver un bouquin prog pour les nuls ou ce genre la.
              Je ne veux pas te décourager, mais la programmation demande
              beaucoup d'expérience et de travail, mais ce qui est génial,
              c'est que si t'aime ca c'est pas du boulot, c'est du loisir.
              • [^] # Re: pour la rapidité chapeau

                Posté par  . Évalué à 2.

                J'ai oublié de mettre les balises html qu'il faut
                au fait désolé j'ai pas fait atenttion que c'était le forum Java
                
                // on s'arrête à TAILLE_TAB - 2 car le tableau sera trié à la fin du tri de 
                // l'avant dernière variable : on ne tri pas une valeur toute seule
                pour i de 0 à TAILLE_TAB - 2 faire
                
                      // recherche du plus petit élément
                               // on commence par initialiser les variables, si besoin
                      dernierPlusPetit = tab[depart + 1]
                      indiceDuDernierPlusPetit = depart + 1
                      pour j de depart à TAILLE_TAB - 1
                             // on regarde les éléments un a un
                             si (dernierPlusPetit < tab[j] ) alors
                                   // si on en trouve un plus petit que le dernier petit connu, 
                                   // c'est le nouveau dernier plus petit
                                   dernierPlusPetit = tab[j]
                                   indiceDuDernierPlusPetit = j
                             finsi
                
                             // On a le dernier plus petit, reste à le mettre à sa place.
                             tmp = tab[depart]
                             tab[depart] = tab[indiceDuDernierPlusPetit]
                             tab[indiceDuDernierPlusPetit] = tmp
                
                      finpour
                
                finpour
                
                • [^] # Re: pour la rapidité chapeau

                  Posté par  . Évalué à 3.

                  Le tri que tu cites m'a pas l'air d'être le tri à bulle, mais le même que le miens, le sélection/permutation.

                  Si mes souvenirs sont bons, le tri bulle c'est plutot une bulle qui "remonte" à partir du fond en remontant à chaque fois le plus petit des deux, genre :
                  (a voir penché, pour imaginer la bulle qui remonte (blup)


                  10 5 2 7 9 4 °| 3 12 |°     12>3 => la bulle chope 3
                  10 5 2 7 9 °| 4 3 |° 12     3<4 => elle remonte 3
                  10 5 2 7 °| 9 3 |° 4 12     3<9 => idem
                  10 5 2 °| 7 3 |° 9 4 12     7<3
                  10 5 °| 2 3 |° 7 9 4 12     => elle chope 2
                  10 °| 5 2 |° 3 7 9 4 12
                  °| 10 2 |° 5 3 7 9 4 12
                        2 10 5 3 7 9 4 12



                  hop on a remonté le 2, maintenant faut recommencer en prenant une bulle qui remonte plus jusqu'en haut.

                  L'avantage c'est qu'à chaque passage tu remontes pas seulement le 2 mais t'as aussi remonté pas mal le "3".

                  Pas en nombre de permutation par contre, mais bon, après faut voir dans des cours d'algos ;)
                  • [^] # Re: pour la rapidité chapeau

                    Posté par  . Évalué à 2.

                    Bien vu.

                    J'avais bien pensé à cet algo aussi, mais ca remonte à mes premiers TD d'algo de DEUG, autant dire que j'ai plus les noms en tête.

                    Perso, je trouve coup des bulles bien sympathique, il est "mignon" cet algo.

                    Enfin, vive les algos en n*log(n) comme le heapsort et le quicksort cités plus haut.
                    Vachement plus intéressant.
        • [^] # Re: Mon préféré : le "tri par bulles"

          Posté par  . Évalué à 1.

          dans ce cas la (intervalle des nombres restreint), si le nombre de valeurs a trier est assez important, le tri comptage est encore plus rapide que le qsort (complexite lineaire par rapport au n*log(n) du qsort)

          http://fr.wikipedia.org/wiki/Tri_comptage(...)
  • # Puisqu'on parle de Java...

    Posté par  . Évalué à 1.

    pourquoi ne pas utiliser les outils fournis par le langage ?

    http://java.sun.com/j2se/1.4.2/docs/api/java/util/Arrays.html(...)

    où l'on trouve une méthode sort pour les tableaux de chaque type de donnée élémentaire.
    • [^] # Re: Puisqu'on parle de Java...

      Posté par  . Évalué à 3.

      mais bien sûr, d'un point de vue pédagogique et surtout si l'on prétend programmer un peu, il me paraît sage d'étudier les algorithmes de tri...
    • [^] # Re: Puisqu'on parle de Java...

      Posté par  . Évalué à 1.

      excus mais t'aurais pas la même chose en français au sujet de sort?
      merci
      • [^] # Re: Puisqu'on parle de Java...

        Posté par  . Évalué à 3.

        Non désolé. Mais si tu me donnes ton adresse je peux venir taper le code sur ton PC pour ne pas t'abîmer les doigts ;-)

        Non sérieusement, faudrait quand même accepter de faire un minimum d'efforts par toi même. Encore une fois si tu prétends programmer un minimum dans un langage un peu sérieux quelques rudiments d'anglais sont indispensables. Surtout que l'anglais en question c'est pas du Shakespeare :
        public class Arrays
        extends Object

        This class contains various methods for manipulating arrays (such as sorting and searching)


        sort

        public static void sort(int[] a)

        Sorts the specified array of ints into ascending numerical order.
        The sorting algorithm is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.

        Parameters:
        a - the array to be sorted.



        Et même si c'est vraiment trop compliqué, Google permet de ne demander que les réponses en français à une recherche, encore faut-il se donner la peine...
        • [^] # Re: Puisqu'on parle de Java...

          Posté par  . Évalué à 0.

          Merci de ta compréhension, je sais comment fonctionne google mais étant donné que tu as l'air d'être depuis plus longtemps que moi en programmation, je pensais que tu avais des sites français sous la main.
          Cependant, si tu ne veux pas perdre de ton temps avec moi, je te laisserais vaquer à tes occupations , c'est sur que d'aider des débutants c'est pitoyable après tout, ils peuvent pas tout savoir eux-mêmes!!!!

          je demandais juste le nom correspondant au mot "échanger" en java mais je crois que c'est trop impertinent pour toi, alors à l'avenir si c'est pour fournir des réflexions de ce genre ne perds pas ton temps avec moi, d'autres auront peut être un petit peu plus de pitié

          Bonne programmation en tous langages et surtout bonne navigation sur google
          • [^] # Re: Puisqu'on parle de Java...

            Posté par  . Évalué à 3.

            je demandais juste le nom correspondant au mot "échanger" en java

            Mais bien sûr, que je suis bête ! C'est évidemment ce que j'aurai du comprendre à la lecture de :

            excus mais t'aurais pas la même chose en français au sujet de sort?

            Je ne préfères pas répondre au reste, vu ce que tu fait des réponses...

            J'attends quand même avec impatience le TP de la semaine prochaine. Et en attendant, puisque le cours de ton prof ne semble pas suffire (à moins que tu ne l'ais pas écouté/lu), je te renouvelle le conseil qui t'a été donné par d'autres de t'acheter (ou d'emprunter) un bon bouquin d'initiation à l'algorithmique et/ou à Java.
            • [^] # algo

              Posté par  . Évalué à 1.

              l'algorithmique est une matière tellement proche des maths et de l'informatique, qu'on ne peut conseiller tel ou tel livre...

              ah , j'avais oublié c'est pas un TP, je suis en train de préparer mon capes de français , alors considère mes exos comme des exos tirés d'un bouquin "java pour les nuls"

              tu sais toujours pas quel est le terme en java pour désigner echanger?
              si tu le trouves merci, moi de mon côté je cherche
  • # algorithmes

    Posté par  (site web personnel) . Évalué à 5.

    Pour trouver des algorithmes généraux sur le web, deux ressources intéressantes sont Wikipédia et le Dictionary of Algorithms and Data Structures. Evidemment en Java, le mieux c'est probablement d'utiliser Arrays.sort().

    http://fr.wikipedia.org/wiki/Algorithme_de_tri(...)
    http://www.nist.gov/dads/HTML/sort.html(...)

    pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

    • [^] # Re: algorithmes

      Posté par  . Évalué à 1.

      question stupide, tu peux développer ton explication sur la méthode? arrays.sort stp?
      merci
      • [^] # Re: algorithmes

        Posté par  (site web personnel) . Évalué à 3.

        Ben c'est le lien qui a été donné plus haut. Suffit de faire un "Arrays.sort(foobar)" et ton tableau est trié. Apparement l'implémentation c'est du quicksort "tuné". L'avantage c'est que c'est déjà écrit, donc ça fait du travail en moins, et on peut être raisonnablement assuré que c'est rapide et sans bug. Si le langage propose déjà des solutions toutes faites, autant les utiliser.

        D'un autre côté si le but est de comprendre et implémenter des algorithmes de tri, ça n'a bien sûr aucun intérêt.

        pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

        • [^] # merci ;))

          Posté par  . Évalué à 1.

          oui c'est sur que d'est plus sympa d'utiliser des fonctions inhérents au langage mais manque de chance , je peux pas ( un peu comme quand t'as la calculatrice , après tu sais plus faire les opérations de tête)
          Pour l'algorithme de tri , je vais utiliser le tri par bulles , faut juste que je gère mes erreurs de syntaxe

          merci en tout cas de tes remarques , fait plaisir de voir que j'intéresse
          ;))
  • # Commentaire supprimé

    Posté par  . Évalué à 2.

    Ce commentaire a été supprimé par l’équipe de modération.

    • [^] # Commentaire supprimé

      Posté par  . Évalué à 2.

      Ce commentaire a été supprimé par l’équipe de modération.

  • # En fait, le plus compliqué c'est encore d'avoir des données pas triées

    Posté par  . Évalué à 1.

    #!/usr/bin/perl -w

    use Data::Dumper;

    # Creer un tableau pas trie
    srand;
    @new = ();
    @old = 1 .. 10;
    while (@old)
    {
    push( @new, splice( @old, rand @old, 1 ) );
    }

    print Dumper (\@new);

    # Trier le tableau
    @sorted = sort {$a <=> $b} @new;
    print Dumper (\@sorted);
  • # Bravo :)

    Posté par  (site web personnel) . Évalué à 3.

    T'a reussi a te faire faire ton TP a premiere vue :p

    Sinon il y a des info sur les algo de tri, en VF, par la :

    http://www.dailly.info/algorithmes-de-tri/(...)

    sinon y'a tjs google
    • [^] # Re: Bravo :)

      Posté par  . Évalué à 2.

      Soit , merci pour le lien vers le site en français , j'ai bien compris la démarche du tri
      cependant au moment où j'éxecute mon code il me reste une erreur

      public class Trial
      {
      public static void main(int tab[])
      {
      tab= new int[9];
      int longueur= tab.length;
      boolean inversion;

      do
      {
      inversion= false;

      for(int i=0; i< longueur-1; i++)
      {
      if(tab[i]> tab [i+1])
      {
      echanger(tab,i,i+1);
      inversion=true;
      }
      }
      }
      while(inversion);
      }
      }

      désolé pour la balise, mais pas fait exprès

      et là il me dit: cannot resolve symbol
      symbol: method echnager

      C'est sur que " echanger" n'est pas le bon terme mis dans ce cas-là c'est lequel? permut?

      merci d'avance
      • [^] # Re: Bravo :)

        Posté par  (site web personnel) . Évalué à 2.

        c'est a toi de coder la fonction echanger comme il faut.

        ou alors tu rempalce echanger(tab,i,i+1); par un truc du genre

        int tmp;
        tmp=tab[i];
        tab[i]=tab[i+1];
        tab[i+1]=tmp;
      • [^] # Re: Bravo :)

        Posté par  (site web personnel) . Évalué à 2.

        Voila alors la c'est encore pire :

        http://www.dailly.info/algorithmes-de-tri/echanger.php(...)

        la fonction est proposée sur le site que je t'ai filé (que j'ai trouver en même pas 5 min sur google au passage) alors comment dire... c'est un peut exaspérant.
        • [^] # ben oui, j'avais trouvé!

          Posté par  . Évalué à 1.

          là je comprends pas ton dernier message, j'avais trouvé via le site que tu m'as donné, mais bon c'est sympa quand même,
          peut être as-tu cru que je n''avais pas trouvé parce que j'ai laissé un message à ( je sais plus son nom), mais ce n'est pas le cas, je lui expliquait juste que certaines personnes ne posent pas des questions pour que leur TP ou Td soient faits par les autres;
          en tout cas, je vous remercie tous mais là j'ai fini , j'ai trouvé la solution alors c'est bon plus de panic

          pour preuve de ma bonne volonté, si vous le souhaitez, je peux vous laisser une méthode de tri pour tableau de string lol
          sujet que je ne vous ait jamais parlé!!!!!!!!!!!!!!
          ah la la , beaucoup de personnes s'inscrivent pour aider les autres et finalement ne font que les descendre, avez vous tous oublié qu'un jour vous avez été débutant? et qu'on apprend pas forcément une matière parce qu'on ai obligé de le faire à l"école? certaines personnes le font par intérêt, par envie, par découverte et ont du plaisir à faire partager les autres de leurs découvertes
          Je vous ferai remarquer également, que certaines personnes se sont contentés de me répondre en me renvoyant à des sites, alors que d'autres ont pensé plus de temps en m'expliquant les choses via un long post.
          C'est sur que je demandais des sites en français et merci pour celui que tu m'as donné calimhero, mais d'autres ont été plus expéditifs!!!!
          si vous ne souhaitez pas aider les autres, pourquoi vous inscrire sur ce forum? Peut être juste pour poser des questions qui vous intéressent?
          On est helper ou on ne l'est pas , alors si un sujet proposé ne vous convient pas vous n'êtes pas obligé d'y répondre, loin de là!!!
          Vous pouvez répondre à tous sujet du moment que vous y répondez correctement

          salutations à tous
          • [^] # Re: ben oui, j'avais trouvé!

            Posté par  (site web personnel) . Évalué à 2.

            Non, si je me suis un peut emporté c'est a cause de ca :

            et là il me dit: cannot resolve symbol
            symbol: method echnager

            C'est sur que " echanger" n'est pas le bon terme mis dans ce cas-là c'est lequel? permut?


            Enfin c'est surtout qu'apres etre passé sur le site que je t'ai donné j'ai vue qu'il traitait de cette fonction avant de passer aux algo de tri dans le meme chapitre. j'en ai donc conclus que t'avais pas tout.

            Et même si ca ne me dérange pas d'aider les grand débutant a faire une recherche sur google (parce que c'est ce que j'ai fait) j'ai bien qu'on lise ce qui a été donné avant de dire que ca marche pas.
            D'ailleurs je t'ai meme donner un bout de code intermediere qui permet de faire ce que fait echanger avant de me rendre compte que tout était sur le site.
            • [^] # soluce fzait maison avec votre aide à tous

              Posté par  . Évalué à 1.

              bon laissons ça là, j'ai fait mon petit code si ça vous intéresse c'est cadeau

              public class tri
              {
              public static void main(String[]args)
              {
              int[]t= new int [args.length];
              for(int i=0;i <args.length; i++)
              t[i]= Integer.parseInt ( args[i]);

              for(int i=0; i<=args.length-2; i++) {
              //recherche du min dans [i.. args.length-1]
              int Im= i;
              for(int j= i+1; j<= args.length-1; j++) {
              if( t[j]< t[Im]) { Im= j;}
              }
              //echange de t[i] avec le min trouvé
              int aux = t[i];
              t[i]= t[Im];
              t[Im]= aux;
              }
              // affichage
              System.out.println ( " tableau trié ");
              for'int i=0; i<= args.length-1; i++) {
              System.out.println ( t[i]);
              }
              }
              }
              voila a+

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.