#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...
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
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.
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);
}
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.
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.
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 : 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
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).
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)
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
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
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.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
J'aime les bandes dessinées, manhuas, manhwas, mangas, comics... Du coup j'ai fait aralosbd.fr !
Prince M
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent