Salut j'aurais besoin d'aide pour réaliser un programme qui effectuerait un tri par comptage ( à l'aide d'un compteur) en java, pourriez-vous m'indiquez la marche à suivre ?

P.S: voici mon programme actuel :

public static void triCompteur(double tab [])
{
int i, j, compt=0;
double tmp;
for(i=0; i<tab.length; i++)
{
for(j=0; j<tab.length; j++)
{
if(j<i)
{
compt++;
}
else{break;}
}
tmp=tab[0];
tab[0]=tab[compt=0];
tab[compt=0]=tmp;
System.out.print(tab[i]+" ");
}
System.out.println(" ");
}

Si vousvoulez le reste de mon programme faites le moi savoir, je ne vous montre là qu'un seule des tri que j'ai à faire.
Le tableau a été déclaré au préalable dans la fonction main et c'est à l'utilisateur dans choisir les valeurs.

Merci!

J'ai pas compris quel est l'algo

Se serait pour trier un tableau en utilisant le tri par compteur, si c'est mon code que tu ne comprends pas il est peut être faux!

non, c'est le tri par compteur que je ne comprends pas

Je pense qu'il parle du "tri comptage" => http://fr.wikipedia.org/wiki/Tri_comptage
Mais au vu de la discussion de l'article (en résumé : "c'est le bon nom ?")... je crois que le plus simple, se serait que tu nous décrives l'algo de ton tri NGC-GAMER.

Bonjour, pardonnez mes périodes d'absence mais je suis en pleine révision de partiel pour mon DUT. Je vous poste mon code dans quelques instants!

Et voila le code complet, il est très long et il y a plusieurs tri:

import java.io.*;
class Ex1 {
public static void main(String[] args)
{

System.out.println("Entrez la taille du tableau");
System.out.println("");
int taille;
taille=lire();
double [] tab= new double [taille];
System.out.println("Saisissez les valeurs du tableau");
saisieTableau(tab);
afficheTableau(tab);
System.out.println(" ");
boolean continuer = true;
int choix;
while(continuer)
{
afficherMenu();
choix=lire();
switch(choix)
{
case 1:
//triMax(tab);
break;
case 2:
triSeq(tab);
break;
case 3:
//triCompteur(tab);
break;
case 4:
triBul(tab);
break;
case 5:
//triFusion(tab);
break;
case 6:
//rechercheDicho(tab,val);
break;
case 7:
continuer=false;
break;
default:
System.out.println("Valeur non possible");
}
}
}
public static void afficherMenu()
{
System.out.println("1: Tri par recherche du maximum");
System.out.println("2: Tri par insertion sequentielle");
System.out.println("3: Tri par compteur");
System.out.println("4: Tri a bulle");
System.out.println("5: Tri par fusion");
System.out.println("6: Recherche par dichotomie");
System.out.println("7: Quitter");
}
/*
public static void rechercheDicho(double tab[], double val)
{

}

public static void triFusion()
{

}
*/
public static void triMax(double tab[])
{
int i, maximum;
double tmp;
int j=tab.length;
while(j>0)
{
maximum = 0;
for(i=1; i<tab.length; i++)
{
if(tab[i]>tab[maximum])
{
tmp=maximum;
maximum=tab[i];
tab[i]=tmp;
}
j--;
}
}
}

public static void triSeq(double tab[])
{
int i, j;
double tmp;
for(i=0;i<tab.length;i++)
{
j=tab.length-1;
while(j>0)
{
if(tab[j]<tab[j-1])
{
tmp=tab[j];
tab[j]=tab[j-1];
tab[j-1]=tmp;
}
else{
j--;}

}
System.out.print(tab[i]+" ");
}
System.out.println(" ");
}
/*
public static void triCompteur(double tab [])
{
int i,s=0,k;
int taille=tab.length;
int nb [] = new int [taille];
int res [] = new int [taille];
for(i=0;i<taille;i++)
{
for(i=0;i<taille;i++)
{
for(k=0;k<taille;k++)
{
if(tab[i]>tab[k])
{
s++;
}
nb[i]=s;
}
res[nb[i]]=tab[i];
s=0;
}
System.out.println("***tableau est trie***\n");
for(i=0;i<taille;i++)
{
System.out.println(res[i]+"");
}
}
}
*/
public static void triBul(double tab [])
{
int i, j;
double tmp;
for(i=0;i<tab.length;i++)
{
for(j=tab.length-1;j>=i+1;j--)
{
if(tab[j]<tab[j-1])
{
tmp=tab[j];
tab[j]=tab[j-1];
tab[j-1]=tmp;
}
}
System.out.print(tab[i]+" ");
}
System.out.println(" ");
}

public static void saisieTableau(double[] tab)
{
int i=0;
while(i<tab.length)
{
tab[i]=lire();
i++;
}
}

public static void afficheTableau(double[] tab)
{
for(int i=0; i<tab.length; i++)
{
System.out.print(tab[i]+" ");
}
System.out.println(" ");
}

public static int lire()
{
String chaine = new String();
System.out.print("Entrez une valeur :");
chaine = lireClavier();
System.out.println();
return (new Integer(chaine).intValue());
}
public static String lireClavier()
{
byte[] lu=new byte[50];
try { System.in.read(lu,0,50); }
catch (IOException e) { System.out.print("Erreur dans la saisie"); }
String s = new String(lu,0,50);
return s.trim();
}
}

P.S. La fonction lire() n'est pas de moi.

Tient ,marrant ,j'ai exactement le même exercice à faire pour mardi

T'es a St LO ?

Ah bah ouais ,on doit être dans la même promo

Ba ouai c meme sur. J'adore les profs qui nous file des trucs trop durs a faire et qui nous aides pas !

Bah ,faut aussi qu'on apprenne à nous débrouiller par nous même dans un sens.

Ouai mais sa reste hyper dure et je sais pas si t'as vu mais il y'a quelque tri du TD qui sont faux. Et dans le cours il n'y a pas d'exemples codes affiliés au exemples de tris. Alors apprendre par nous même dans ces conditions me parait difficile. Mais on ne va pas se plaindre vue que les profs sont quand même vachement compétents!

Bah personnellement ,j'ai recherché les algorithmes détaillés pour comprendre les méthodes. Par contre ,y a justement un tri qui me dérange ,c'est le tri compteur. Dans le TP ,on nous demande de saisir un tableaux de réels que l'on triera avec plusieurs méthodes. Or ,tous les endroits où j'ai cherché ,il est dit que ce tri par compteur est adapté pour trier des entiers et pas pour autre chose. D'ailleurs ,c'est le tri qu'on avait à effectuer derrière ces histoires de compression/décompression au partiel la semaine dernière. Là pour le coup ,je vois pas trop ce qu'on nous demande :/

Ouai pareil, j'ai essayer de le faire mais j'ai pas réussi.

« Et dans le cours il n'y a pas d'exemples codes affiliés au exemples de tris. » tu prends n'importe quel bouquin abordant l'algorithmique niveau licence et tu fouilles dedans. Ce n'est pas dur de trouver des exemples de tris.

Au pire, tu as aussi wikipedia, mais attention, il y a sûrement des des fautes dedans.

Votre examem est passe, mais je vais quand meme essaye de lever les incomprehension.

Le tri compteur qui est presente dans le premier code repose sur l'idee suivante:
-pour chaque entre du tableau i
-compter combien d'entre j sont avant moi.
-si il y a K valeur plus petite que tableau[i] alors la ieme entree du tableau sera a la position K une fois trie.

Si toutes les entrees du tableau sont differentes, l'implementation est relativement simple a faire. Si plusieurs entree sont egales, il faut faire attention quand on decide si i est avant j: si tableau[i]> tableau[j] alors j est avant i. Si tableau[i] < tableau[j] alors j est apres i. si tableau[i]=tableau[j], alors il faut une regle pour prendre la decision, par exemple i<j alors i est avant j.

Ce tri peu etre applique a tous les types pourvu que l'on dispose d'un moyen de comparer tableau[i] et tableau[j].

Il existe un tri qui porte un nom similaire. Souvent appele le tri par comptage. Celui ci ne fonctionne que sur des entiers. L'idee ici est de compter combien de fois chaque entier apparait dans le tableau. Si tous les entiers sont compris entre 0 et N, on cree le tableau compt de N+1 entiers. Et on fait en sorte que compt[i] soit le nombre de fois que l'entier i apparait dans le tableau. Une fois ce tableau rempli, on peut facilement obtenir le tableau original trie en suivant le principe suivant: les compt[0] premieres valeures sont 0, les compt[1] suivante sont 1, les compt[2] suivantes sont 2...