Quelques questions concernant les tableaux

Sujet résolu

18 juillet 2006 à 19:20:54

Re les zéros,
J'ai quelques questions à vous posez : premièrement dans son cour matéo dit que écrire *tableau revient à écrire tableau[] car il s'agît d'un pointeur.
Est ce que de ce fait, je peut remplacer *(tableau + 1) par tableau[i] + 1.

Deuxièmement, je n'arrive pas à finir l'exercice 5 quelqu'un peut-il me donner un indice sur mon erreur ?
voila mon code

#include <stdio.h>
#include <stdlib.h>
#include "affichage.h"

void ordonnerTableau(long tableau[], long tailleTableau);

int main(int argc, char *argv[])
{
head();

long tableau[4] = {81, 32, 15, 5}, tailleTableau = 4, i = 0;

ordonnerTableau(tableau, 4);

printf("Dans l'ordre, le tableau devient : %ld\n", tableau[i]);

}

void ordonnerTableau(long tableau[], long tailleTableau)
{
long i, tempo;

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

while (tableau[i] > *(tableau + 1))
{
tempo = tableau[i];
tableau[i] = *(tableau + 1);
*(tableau + 1) = tempo;

}

}

}

Tester mon code vous verrez ce que j'obtient

coyotte49

18 juillet 2006 à 20:16:55

Déjà, je te préviens, ce dernier exo est un grand cran au dessus point de vue difficultée. Alors, oui, ces 2 facons d'écrire sont équivalentes :
tableau[i] <=> *(tableau + i)

Edit : Je viens de voir que c'est pas exactement ce que tu as écris. Ca m'apprendra à lire trop vite.

Tu proposes : *(tableau + 1) par tableau[i] + 1. C'est pas correct. C'est plutot *(tableau + i + 1) par tableau[i + 1], mais je vois pas trop l'utilité de faire ca.

Mais, je vois pas trop l'utilité de ce que tu fais dans ta boucle. On en reparle après...

Déjà, #include "affichage.h", c'est quoi ? Que contient ce fichier affichage.h ? head(), c'est quoi ? Ensuite, tu n'as pas mis de système pause ou getchar à la fin de ton programme... Donc, forcément, il va se ferme tout de suite. Et enfin, ton printf veut afficher tableau[i], mais comme i = 0, il va juste afficher le premier élément. Or, ce que tu veux, c'est afficher tout le tableau. Pour ca, il faut utiliser une boucle :

for (i = 0; i < 4; i++)
printf("Dans l'ordre, le tableau devient : %ld", tableau[i]);

Réponds déjà à mes questions du dessus et retravaille encore un peu ta fonction ordonnerTableau. Si tu trouves pas, on te donnera une solution (ca serait normal si tu trouves pas, c'est pas facile).

Bonne chance

PS : Pour ta fonction, utilise simplement tableau[i], sinon, ca serait se compliquer la vie pour rien.

Nephis

18 juillet 2006 à 20:24:51

"affichage.h"
contient ma fonctione void head, c'est juste un ensemble de printf pour faire joli je le met à chaque fois

Donc daccord je laisse *(tableau + 1) après tout pourquoi ce compliquer la vie.

En faite je voulé utiliser la boucle pour dire tant que le tableau n'est pas en ordre fait ceci, ...
Mais je vais éssayer d'une autre manière..

edit : system pause n'est pas obligatoire, j'utilise code blocks

coyotte49

18 juillet 2006 à 20:31:14

Non non, je ne change pas trop. Tu utilises 2 boucles et un tempo, c'est très bien parti.

Nephis

18 juillet 2006 à 20:44:37

edit : Erf ça ne fait rien du tout

#include <stdio.h>
#include <stdlib.h>
#include "affichage.h"

void ordonnerTableau(long tableau[], long tailleTableau);

int main(int argc, char *argv[])
{
head();

long tableau[4] = {81, 32, 15, 5}, tailleTableau = 4, i = 0;

ordonnerTableau(tableau, 4);

printf("Dans l'ordre, le tableau devient :\n\n");
for (i = 0; i < 4; i++)
printf("%ld\n", tableau[i]);

return 0;
}

void ordonnerTableau(long tableau[], long tailleTableau)
{
long i, tempo;

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

while (tableau[i] > *(tableau + i))
{
tempo = tableau[i];
tableau[i] = *(tableau +i);
*(tableau +i) = tempo;

}
tailleTableau--;
if(tailleTableau != 0)
ordonnerTableau(tableau,tailleTableau);

}

}

richidi

18 juillet 2006 à 21:19:54

essaye ca

#include <stdio.h>
#include <stdlib.h>
void ordonnerTableau(long tableau[], long tailleTableau);

int main(int argc, char *argv[])
{
long tableau[4] = {81, 32, 15, 5}, tailleTableau = 4, i = 0;

ordonnerTableau(tableau, tailleTableau );

for (i = 0; i< tailleTableau; i++)
{
printf("Dans l'ordre, le tableau devient : %ld\n", tableau[i]);
}
}

void ordonnerTableau(long tableau[], long tailleTableau)
{
long i, j, tempo;
for (j = 0 ; j < tailleTableau ; j++)
{
for (i = 0 ; i < tailleTableau ; i++)
{
if(tableau[i] > tableau[i + 1])
{
tempo = tableau[i] ;
tableau[i] = tableau[i + 1];
tableau[i + 1] = tempo;
}
}
}
}

Nephis

18 juillet 2006 à 21:27:43

Merci ca marche.. bah je n'était pas si loin

richidi

18 juillet 2006 à 21:33:02

Il ya plusieurs algo pour trier.
Mais celui la c'est le plus trash. Tu dois repeter le parcours du tableau autant de fois qu'il ya d'elements....
Voici les tris les plus connus:
Selection Sort
Insertion Sort
Shell Sort
Bubble sort
Quicksort

coyotte49

19 juillet 2006 à 14:28:26

Je me permet d'ajouter un message, parce que je pense que tu n'as pas bien compris Reivax. Je veus pas jouer les rabats-joies, mais tu étais assez loin du compte :). Ta boucle principal, si on traduit (en remplacant *(tableau +i) par tableau[i], qui sont exactement pareil), ca donne ça :

while (tableau[i] > tableau[i])
{
tempo = tableau[i];
tableau[i] = tableau[i];
tableau[i] = tempo;

}

Ce qui ne veut absolument rien dire. Tu n'auras jamais tableau[i] > tableau[i], donc, on rentre jamais dans ton while.

Quand on te dis que *(tableau +i) et tableau[i] sont équivalents, ca veut dire que le compilateur, pour lui, c'est exactement la même case mémoire, donc les mêmes valeurs.
Concernant l'intérieur de ta boucle, tu ne saurais pas y arriver, puisque tu travailles toujours avec le même élément.
Si tu veux triller 5 choses, tu vas d'abord comparer la premiere avec la 2e. Ca donnera :
tableau[0] et tableau[1]
Si tu veux comparer la 2e et la 3e, ca sera :
tableau[1] et tableau[2]
etc.
Pour ne pas coder laidement, on utilise une boucle (mais je vais t'expliquer sans boucle) :
1ere tour de boucle : tableau[i] et tableau[i + 1] // i vaut 0
=> tableau[0] et tableau[0 + 1]

2e tour : tableau[i] et tableau[i + 1] // i vaut 1
==> => tableau[1] et tableau[1 + 1]
etc.

Donc, ca donnera :

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

while (tableau[i] > tableau[i + 1])
{
// Ici qu'on va ordonner.
}
}

V'la l'explication de l'intérieur de la boucle.
On image que tableau a comme valeur 15,9 (au final, on doit obtenir 9,15). Au début, on compare tableau[0] = 15 et tableau[1] = 9.
15 est plus grand que 9, donc, 15 doit venir après 9. Au final, on aura donc :
tableau[0] = 9 et tableau[1] = 15
Il faut donc échanger leur place. On va commencer par mettre la premiere valeur (9) à la place de l'autre (15).

tableau[0] = tableau[1]
A partir de maintenant, tableau 0 vaut 9, alors qu'il valait 15 avant. La première étape est réussie. Il faut maintenant faire passer 15 dans tableau[1].
C'est là que temp intervient. En effet, la valeur 9 est présente dans tableau[0] (on vient de la mettre) ET dans tableau[1] (initialement). Il faut donc stocké 15 au départ pour ne pas "l'oublier".
Ca donne :

temp = tableau[0] // temp vaut 15, on le stocke
tableau[0] = tableau[1] // tableau[0] vaut 15 et tableau[1] vaut 9
// Maintenant, tableau[0] vaut 9 aussi. Si on avait pas temp, 15 ne serait plus stocké nul part.

Il reste plus qu'à mettre 15 à la suite de 9.

temp = tableau[0] // temp vaut 15
tableau[0] = tableau[1] // tableau[0] vaut 15 et tableau[1] vaut 9
/* Maintenant, tableau[0] vaut 9 aussi. Si on avait pas temp, 15 ne serait plus stocké nul part. */
tableau[1] = temp;

Après, il suffit de mettre ca sous forme de boucle et le tour est joué.
On utilise une 2e boucle pour que tout soit bien classé, parce que avec tout ce que je t'ai expliqué, on a décallé les chiffres d'un seul rang.

J'espère que tu liras ce message, histoire que je ne me sois pas amuser à taper ca pour rien :-°

@ +

Et les autres, hésitez à dire si j'ai dis des coneries