DEBUTANT EN C

Bonjour a tous
Débutant en c j'ai écrit un truc qui sert pas a grand chose sinon classer en
ordre croissant décroissant et pyramidal le contenu d'une variable
voir le code à la suite. n'étant pas spécialement content de mon code je
m'adresse au pro du c++ que vous êtes pour me donner une piste
pour optimiser mon code, notament pour récuperer la taille de TabValue car
quand je fais un ntaille = TabValue.size() ca le fais pas probleme de typage
des variables sans aucun doute mais je vois pas :(

d'avance merci a vous
Michaël

adresse mail : diablofr_arrobase_live.fr.

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

// DEFINITION DE VRAI ET FAUX
#define TRUE 1
#define FALSE 0
#define s32 signed long


// chaine originale c'est celle que tu m'a donné

//s32 TabValue[] = { 0, 10, 22, 33, 44, 55, 66, 77, 80 };


// Déclaration du tableau
// j'ai rajouté deux éléments et j'ai mélangé les entiers sinon c'était
trop facile ;-)
// les deux éléments rajoutés c'est pour la pyramide

s32 TabValue[] = { 22, 10, 44, 33, 66, 55, 80, 77, 134 , 3, 19 , 12 , 99,
121 , 130} ;


// ***********************************************************************/
// * DECLARATION DES VARIABLES

int i; // compteur
int k;
int pyram =0; // pour l'impression pyramidale
int num; // option du menu
int ntaille; // recupera la taille du tableau
int cpt = 1;
// **********************************************************************/

// FONCTION DE TRI PYRAMIDAL
void tri_pyramidal(int *t, int n)
{
int j = 0; // pour la boucle
int tmp = 0; //permet la permuation
int en_ordre; // condition de boucle
while(en_ordre) // boucle
{
en_ordre = FALSE; // en ordre = faux pour boucler
for(j =0 ; j < n-1 ; j++) // si t[j] > t[j+1] si la case tabvalue
en cours est plus grande que la case suivante de TabValue alors
{
if (t[j] < t[j+1]) // si t[j] < t[j+1] si la case TabValue en
cours est plus petite que la case suivante de TabValue alors
{
tmp = t[j+1]; // permutation = Tabvalue +1
t[j+1] = t[j]; // Tabvalue + 1 = TabValue en cours
t[j] = tmp; // TabValue en cours = permutation
en_ordre = TRUE; // en ordre = Vrai Fin de la procédure de
tri
}
}
}
}


// FONCTION DE TRI CROISSANT

void tri_croissant(int *t,int n)
// EXPLICATION
// t = TabValue, n = taille de TabValue
{

int j =0; // pour la boucle
int tmp = 0; // permet la permutation
int en_ordre; // condition de boucle
while(en_ordre) // boucle
{
en_ordre = FALSE; // en ordre = faux pour boucler
for (j = 0 ; j < n-1 ; j++) // si j est plus petit que la taille du
tableau -1 on incrémente
{
if (t[j] > t[j+1]) // si t[j] > t[j+1] si la case tabvalue en
cours est plus grande que la case suivante de TabValue alors
{
tmp = t[j+1]; // temp = t[j+1] soit temp = case suivante de
TabValue
t[j+1] = t[j]; // Case suivante de TabValue = case
précédente de TabValue parce que son contenu est forcément plus petit
t[j] = tmp; // Case en cours de TabValue = à la valeur temp
mise de coté plus haut
en_ordre = TRUE; // en_ordre = Vrai fin de la procédure de
tri
}
}

}

}



// FONCTION DE TRI DECROISSANT
void tri_decroissant(int *t, int n)
{
int j = 0; // pour la boucle
int tmp = 0; //permet la permuation
int en_ordre; // condition de boucle
while(en_ordre) // boucle
{
en_ordre = FALSE; // en ordre = faux pour boucler
for(j =0 ; j < n-1 ; j++) // si t[j] > t[j+1] si la case tabvalue
en cours est plus grande que la case suivante de TabValue alors
{
if (t[j] < t[j+1]) // si t[j] < t[j+1] si la case TabValue en
cours est plus petite que la case suivante de TabValue alors
{
tmp = t[j+1]; // permutation = Tabvalue +1
t[j+1] = t[j]; // Tabvalue + 1 = TabValue en cours
t[j] = tmp; // TabValue en cours = permutation
en_ordre = TRUE; // en ordre = Vrai Fin de la procédure de
tri
}
}
}
}



// fonction principal
int main(void)
{


// présentation
printf("Programme : Algorithmes De Tri / %c Version 01 Le
23/11/2011\n",184);
printf("R%calis%c par: MICHAEL AMZEL \n", 130, 130);
printf("Encadr%c par: CHRISTOPHE NAZARET \n\n",130);


// rappel du contenu de TabValue
printf ("\n\nVoici le contenu de la variable TabValue.\n\n");
for (i = 0 ; i < 15 ; i++)
{
printf("%d ", TabValue[i]);
ntaille = ntaille++;
}

printf("\n\n");
// liste des algorithmes de tri
printf("\n1. Le tri par ordre Croissant\n");
printf("2. Le tri par ordre D%ccroissant\n",130);
printf("3. Le tri pyramidale\n");
// choisir l'algorithme à appliquer

// boucle pour tester l'entrée clavier saisie par l'utilisateur
do {
printf("\nVeuillez saisir le num%cro de l'algorithme de tri %c appliquer
: ",130,133); // affichage du message : Veuillez saisie le numéro de
l'algorithme de tri a appliquer
scanf("%d",&num); // recupere la saisie clavier
if ((num>6)||(num<1)) printf("\n(!) Ce num%cro ne figure pas dans la
liste !\n",130);} // message d'erreur comme quoi le numéro n'est pas dans le
choix des options possible
while((num>3)||(num<1)); // verifie que l'option entrée fais partie de
la liste


// appliquer l'algorithme choisi
//on passe en argument : TabValue, la Taille de TabValue et le numéro de
l'option comme ca y a qu'une fonction de tri au lieu d'en avoir trois
if (num==1) tri_croissant(TabValue, ntaille);
if (num==2) tri_decroissant(TabValue, ntaille);
if (num==3) pyram =1; tri_pyramidal(TabValue, ntaille);

// si pyram = 0 alors on affiche le resultat normalement pour le tri
croissant et décroissant
if(pyram == 0)
{
// résultat pour tri croissant et décroissant
printf("\nTRI%cS! : ",144); // AFFICHE LE MESSAGE SUIVANT : TRIES
MAIS AVEC UN ACCENT
for (i=0 ; i<ntaille ;i++) // BOUCLE SUR LA LECTURE DE TabValue
printf("%d ",TabValue[i]); printf("\n\n"); // affiche la case
mémoire TabValue en cours et passe à la ligne suivante

}
else
// Si pyram = 1 alors on affiche le tri pyramidal
// EDITION TRI PYRAMIDAL
{
int ligne = 0;// pour la boucle
int valeur = (ntaille /2) -1;
int caselue = 0; // lecture de la case memoire en cours
for (i = 0 ; i < valeur ; i++) // boucle pour la lecture du
tableau tant que i< ntaille alors on ajoute 1 à i
{
for(ligne = 0 ; ligne < i ; ligne++) // boucle pour la
pyramide si ligne < i alors on ajoute 1 à ligne
{
printf("%d ",TabValue[caselue]); // affichage de la
valeur TabValue en cours
if (caselue < ntaille ) // si caselue < ntaille
alors
{
caselue++; // on increment caselue
}

}
printf("\n"); // on passe a la ligne suivante
}
}

system("PAUSE"); // on fait une pause après l'affichage du résultat
return 0; //on renvoie 0 et on termine le programme
}// fin du programme