Tout d'abord, bonsoir chers programmeurs.

Etant bloqué depuis une petite heure sur le problème et n'arrivant pas à déceler ma faute, je viens poster mon code dans le but que vous m'aidiez à la comprendre, cette erreur !

Alors, le programme a pour but de trier par ordre croissant 6 valeurs que j'aurai préalablement rentré.

Voici la [s] toute petite [/s] bête :

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

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

int main()
{
    int i,a,b,c,d,e,f;
    printf("Entrez les 6 valeurs a classer : ");
    scanf("%d",&a);
    scanf("%d",&b);
    scanf("%d",&c);
    scanf("%d",&d);
    scanf("%d",&e);
    scanf("%d",&f);
    int tableau[6] = {a,b,c,d,e,f};
    ordonnerTableau(tableau, 6);
    printf("Les nombres sont dans l'ordre : \n");
    for (i = 0 ; i < 6 ; i++)
    {
        printf("%d\n", tableau[i]);
    }
}


void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i;
    int t[tailleTableau];
    for (i=0;i < tailleTableau;i++)
    {
        t[i]=tableau[i];
    }
        for (i=0;i < tailleTableau-1;i++)
        {
            if (t[i]>t[i+1])
            {
                tableau[i]=t[i+1];
                tableau[i+1]=t[i];
            }
        }

}

Je vous remercie à l'avance, en espérant que je ne fus pas si loin .

Bonne soirée !

-
Edité par pdeuez 30 janvier 2013 à 0:08:23

d'une ne fais jamais ça:

t[tailleTableau]

Et de deux, regarde ton algo:

Admettons tu as 8 6 5 3, tu vas faire cela: 6 8 5 3 -> 6 5 8 3 -> 6 5 3 8 et c'est fini. Tu compare la valeur d'un chiffre que par rapport a celui qui suit. Il te faut prendre ton premier element et le comparer a tous ceux qui suivent, a chaque fois que l'élement en question est superieur tu l'intervertit, puis tu fais la même chose avec le deuxieme element et ceux qui suivent. Il te faut une boucle imbriqué dans une boucle.

Ah d'accord merci beaucoup ! Pour cela, je dois utiliser une deuxième boucle for avec un j cette fois par exemple ? Ou puis-je faire une boucle pour que cette comparaison ne s'arrête pas tant que tableau[0] < tableau[1] < tableau[2] < tableau[3] < tableau[4] < tableau[5] ?

bah admettons ton tableau est 6 8 4 3

tu prends le 6 et tu le comapare a 8 (pas dechange) a 4 (echange) du coup mtn c 4 que tu compare a 3, deuxieme tout de boucle le tableau est maintenant comme ceci:

3 8 6 4

tu compare 8 avec 6(echange), 6 avec 4(ecahnge)

3 4 8 6

tu comapre 8 avec 6 (echange) fin

3 4 6 8

Bonsoir tout le monde. Je viens de faire l'exercice de fonction de tri d'un tableau, et j'aimerais avoir vos commentaire sur mon code, si vous voulez bien.

Donc, mon code est le suivant :

void ordonnerTableau(int tableau[], int tailleTableau) //cette fonction ordonne les valeurs du tableau dans l'ordre croissant
{

       //il faut utiliser la valeur tailleTableau
       // l'idée est de prendre la premiere case, de la comparer à toute les autres, et à chaque fois que la premier valeur est sup, faire le remplacement
       // on devrait avoir la plus petite valeur en premiere case.
       //ensuite, on recommence avec la deuxieme case.

       int i = 0;


       for ( i = 0; i < tailleTableau ; i++)
        { int ibis = 1;

            for (ibis = 1; ibis < (tailleTableau - i); ibis++) // comparer tableau[i] avec tableau[i + ibis]
            {

                if ( tableau[i]>tableau[i+ibis])   //lors du premier cycle (i = 0) (ibis = 1), ca compare tableau[0] à tableau[0 + 1]
                                                   // puis on repart dans la boucle for, on revient (i = 0) , (ibis = 2), on compare tableau[0] à tableau [0+2]
                                                   // à la fin on aura la plus petite valeur à tableau[0], non ?
                {
                    int stocka=0;                  //là je fais des copies des valeurs pour pouvoir les intervertir, je stock les valeurs dans stocka et stockb
                    int stockb=0;

                    stocka = tableau[i];
                    stockb = tableau[i+ibis];

                    tableau[i] = stockb;
                    tableau[i+ibis] = stocka;
                }

            }

        }

}

Apparemment, ça marche. Est-ce que c'est infaillible  à votre avis ?

Comment pourrais-je l'améliorer ?

Et merci magellan pour l'idée de la boucle dans la boucle !

-
Edité par igorgor 30 janvier 2013 à 2:45:21

Tu peux déclarer tes variables au début de ta fonction. Pas trop utile ici de les déclarer à chaque tour de boucle. Aussi un échange de donnée se fait en 3 lignes.

Tu peux déclarer tes variables au début de ta fonction. Pas trop utile ici de les déclarer à chaque tour de boucle.

C'est très bien comme ça, les variables ne sont visible qu'a l'endroit ou on les utilise. Le compilateur t'optimisera ça sans problème si tu peur des performances.

Aussi un échange de donnée se fait en 3 lignes.

C'est juste, il n'y a besoin que d'une variable de stockage en fait.

@peut être mais c'est très laid D:

Dans ce cas aussi bien déclarer "ibis" directement dans le second for et le i dans le premier.

De ce point de vue ce serait mieux en effet, mais ça n'est pas compilable en C89.

Merci bien moins1 et simbilou

Pour l'échange de donnée, ça donnerait ça par exemple ?

//je veux échanger les valeurs de tableau[i] et tableau[i+ibis]

int stock=tableau[i];
tableau[i]=tableau[i+ibis];
tableau[i+ibis] = stock;

-
Edité par igorgor 30 janvier 2013 à 14:34:05

@igorgor : oui.

@magellan : c'est bien de lire tous les posts aussi.

Salut à tous!

Désolé de réveiller le chat qui dors depuis une année, mais j'aimerais savoir comment créer un programme qui ordonne les valeurs d'un tableau de 20 cases (p.ex) car ceux du dessus sont assez commode pour des petits tableaux.

Merci

-
Edité par J@son7 28 juillet 2014 à 21:45:30

Bonjour,

Avec Google tu trouveras sans problème des exemples tous faits.

Ici, c'est pour ceux qui ont commencé à écrire un programme, et qui ont besoin d'aide parce qu'ils ne trouvent pas les erreurs.

En effet, j'ai commencé avec le C, j'ai essayé le code de pdeuez en essayant de l'améliorer selon les recommandations de Ivankov04. Mais le programme bloque toujours au bout de 4 tours de boucle. Comment augmenter les tours de boucle pour ordonner tout car le fait qu'il y ai 4 éléments dans le tableau ne veut pas forcément dire qu'il faudrait aussi 4 tours pour les ordonnés.

PS: Il faut que ce soit valide en C89

Le code d'Ivankov04 me semble bien pour ordonner 20 éléments (ou même 100, mais pas 1000000).

Merci, j'ai du mal a assimilé le fonctionnement des boucles imbriquées!

J@son7 a écrit:

Merci, j'ai du mal a assimilé le fonctionnement des boucles imbriquées!

Normal que tu aies du mal. Si c'était évident, ça serait pas un métier.

C'est pour ça qu'il faut que tu fasses des exercices PAR TOI MËME.  Tu peux regarder quelqu'un jouer du piano et te dire que tu as bien compris, ça ne t'apprend rien. Pour apprendre, il faut que mettes tes petits doigts à toi sur le clavier. Pareil pour commencer la programmation, les exercices faits par les autres, ça ne t'apprend rien (si, plus tard, quand tu sauras faire, ça te permettra d'apprendre à trouver rapidement les erreurs des autres, mais on n'en est pas là).

Merci beaucoup!

Je tacherai de m'appliquer dès à présent.

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

int main(int argc, char *argv[])
{
    int tableau[19] = {7,4,1,8,5,2,9,6,3,19,18,17,16,15,14,10,12,13,11};
    ordonnerTableau(tableau,19);
    afficheNouveauTableau(tableau,19);
    return 0;
}
void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i,j=1,temp,c=tailleTableau-2;
    for(i=0;i<tailleTableau-1;i++)
    {
        for(j;j<tailleTableau;j++)
        {
            if(tableau[i]>tableau[j])
            {
                temp=tableau[i];
                tableau[i]=tableau[j];
                tableau[j]=temp;

            }
        }
        j=j-c;
        c--;
    }

}
void afficheNouveauTableau(int tableau[], int tailleTableau)
{
    int k;

    for (k = 0 ; k < tailleTableau ; k++)
    {
        printf("%d\n", tableau[k]);
    }
}

est ce qu'il y a des fautes ou des commentaires et mercii

-
Edité par ayoubanane 31 juillet 2014 à 23:09:00

Tu as déjà mis ce programme ailleurs, me semble-t-il.
Quelqu'un t'a fait des remarques sur les noms des fonctions, et la suppression du bricolage des lignes 28 et 29.

Bonsoir, Je cherche un peu d'aide sur ma fonction pour ordonné un tableau

void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i =0,mem=0;
    for (i=0; i<tailleTableau; i++)
    {
        if (tableau[i]<tableau[0])
        {
            mem=tableau[i];
            tableau[i]=tableau[0];
            tableau[0]=mem;
            i=0;
        }
    }

}

j'arrive pas a voir ou ca coince pourtant pour le tableau : 10-5-4-54-0

ca me retourne 0-10-5-54-4

-
Edité par Anonyme 25 août 2014 à 20:57:44

Ca fait exactement ce que tu as dit de faire : comparer successivement tous les éléments du tableau, et les changer avec la première case si ils sont plus petits. Ce qui aura pour effet d'amener le plus petit élément du tableau dans la première case.

C'est un bon début. Reste à mettre le second plus petit élément dans la seconde case, puis le troisième etc.

Il ne suffit pas que la fonction s'appelle ordonnerTableau pour que ça ordonne le tableau.

-
Edité par michelbillaud 27 août 2014 à 10:27:39

bonsoir ,j'ai un problème concernant mon code de ordonnerTabeau :

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

int main()
{
    int tableau[4]= {15, 81, 22, 13};
    int i;
    ordonnerTableau(tableau,4);
    for(i=0;i<4;i++)
        printf("%d\n",tableau[i]);
    return 0;
}
void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i,j,compteur ;
    for(i=0;i<tailleTableau-1;i++)
    {
       for(j=i+1;j<tailleTableau;j++)
       {
           if (tableau[j]<tableau[i])
            compteur=tableau[i];
            tableau[i]=tableau[j];
            tableau[j]=compteur;


       }
    }
}

T'as oublié les accolades pour le if

Drôle de nom pour une variable temporaire que "compteur"!

La méthode de permutation présentée est à la fois plus compliquée et moins performante que la méthode standard.

Si on veut optimiser,  au lieu de faire reprendre i à 0 à chaque boucle for, on pourrait repartir de l'endroit où a eu lieu la première permutation. Et jusqu'à celui où a eu lieu la dernière.

-
Edité par michelbillaud 12 février 2017 à 20:14:52

michelbillaud a écrit:

La méthode de permutation présentée est à la fois plus compliquée et moins performante que la méthode standard.

Et en plus elle a un comportement indéterminé en cas de dépassement de limite de int.