CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 05 27 13:29:38

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

ALGORITHMES DE TRIS

Information sur la source

Note :
Aucune note

Catégorie :Application Classé sous :tri, insertion, sélection, dénombrement, rapide Niveau :Débutant Date de création :09/12/2005 Vu / téléchargé :8 597 / 368

Auteur : NNAS

Ecrire un message privé

Commentaire sur cette source (9)

Ajouter un commentaire et/ou une note

Description

Cet algo permet de comparer quelques tris de base (tri rapide, par insertion, par selection, par dénombrement)

Source

//**********************************************************************************
// Ce programme permet de comparer la complexit‚ des differents algorithmes de tris
// il a été écrit par NTCHANA NYAMSI ARLAIS
//**********************************************************************************
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<time.h>
#define N 4000
// nos d‚clarations
int k,choix;
int tab[N],vect [N];
int longueur = 100;
int pas=200; // déclaration du pas
clock_t first, second; //Mesure du temps
//*******************************************************************************
// procédure affiche
// Permet d'afficher les valeurs du tableau
// (on vérifie avec cette proc‚dure que le tableau est bien tri‚)
//****************************************************************************************************
void affiche(int t[N],int max)
{
int m;
//clrscr();
for (m=0; m<max;m++) printf(" %4d",t[m]);
//getch();
}
//*************************************************************************************************
// proc‚dure generervecteur
// Elle permet de remplir de maniŠre al‚atoire max +1 case d'un tableau de N ‚l‚ments
//*************************************************************************************************
void generervecteur(int tab[N],int longueur)
{
int i;
randomize();
for( i=0;i<longueur;i++)
{
tab[i]= /*i+1;*/ rand() % longueur;
}
}
//*************************************************************************************************
// procédure recopie
// Cette fonction permet de faire la copie d'un tableau … un autre
//*************************************************************************************************
void recopie(int tab[N],int vect[N],int longueur)
{int i;
for(i=0;i<longueur+1;i++) vect[i]=tab[i];
}
//********************************************************************************************************
// procédure tris_rapide
//
// Le tri rapide est un algo bas‚ sur le paradigme "diviser pour regner" son temps d'‚x‚cution dans le pire
// des cas est O(ný). Par contre il est souvent le meilleur choix en pratique, … cause de son efficacit‚
// remarquable en moyenne : son temps d'‚x‚cution attendu est O(nln n)
//
//********************************************************************************************************
/**************** Ecriture de la proc‚dure PARTITIONNER ******************************/
int PARTITIONNER (int tab[],int p,int r)
{
int i,j,x,temp,vrai = 1;
x = tab[p];
i = p-1;
j = r+1;
while (vrai/*vrai !=0*/)
{
do j --; while ( tab[j] > x );
do i++ ;while(tab[i] < x);
if (i<j)
{
temp = tab[i];
tab[i] = tab[j];
tab[j] = temp ;
}
else
{
vrai = 0;
return(j);
}
}
return(j);
}
//*********************** Ecriture de la proc‚dure TRI RAPIDE *****************************************
void TRI_RAPIDE (int tab[N], int p ,int r)
{
int q;
if ( p < r )
{
q = PARTITIONNER (tab,p,r);
TRI_RAPIDE (tab, p, q);
TRI_RAPIDE (tab, q+1, r);
}
}
//*************************************************************************************************
// proc‚dure TRI PAR INSERTION
//
// Le tri par insertion est un algorithme efficace quand il s'agit de trier un petit nombre d'‚l‚ments
// Le temp d'‚x‚cution dans le pire des cas est en O(n2)
//*************************************************************************************************
void TRI_INSERTION(int tab[],int longueur)
{
int j, cle, compt, vrai;
for(j=1;j<longueur;j++)
{
cle=tab[j];
//insertion de tab[j] dans la s‚quence tri‚e tab[0..j-2]
compt=j-1;
do
{
vrai=0;
if (tab[compt]>cle)
{
tab[compt+1]=tab[compt];
compt--;
vrai=1;
}
if (compt<0) vrai=0;
}
while(vrai);
tab[compt+1]=cle;
}
}
//*************************************************************************************************
// proc‚dure tris par selection
//************************************************************************************************
void TRI_SELECTION(int tab[N])
{
int t[N],k,temp,i,j;
for(i=0;i<longueur;i++)
{
k=i;
for(j=i+1;j<longueur;j++)
{
if(tab[j]<tab[k]) k=j;
}
temp=tab[i];
tab[i]=tab[k];
tab[k]=temp;
}
};
//*************************************************************************************************
// proc‚dure TRI PAR DENOMBREMENT
//
// Le principe du tri par d‚nombrement est de d‚terminer pour chaque ‚lt x de l'entr‚e, le nombre
// d'‚lts inf‚rieurs … x. Cette information peut sevir … placer l'‚lt x directement … sa position
// dans le tableau de sortie
// ce tri s'‚x‚cute en O(n) lorsque le plus grand ‚lt k est tel que k=O(n)
//*************************************************************************************************
//************************ Algorithme qui recherche le max du tableau ******************************************
int CHERCHEMAX ( int tab[], int longueur)
{int i, temp = 0;
for (i=0; i<longueur; i++)
if (tab[i] > temp )
temp = tab[i];
return(temp);
}
//************************ Proc‚dure TRI PAR DENOMBREMENT ******************************************
void TRI_DENOMBREMENT (int tab[],int tab2[],int k)
//tab[] tableau non tri‚; tab2[] tableau qui au sortir de la proc‚dure sera tri‚; k plus grand entier
{int tab3[N]; int i,j;
for ( i=0; i<k+1; i++) tab3[i]=0;
for (j=0; j<longueur;j++) tab3[tab[j]]++;
// tab3[i] contient … pr‚sent le nombre d'‚lt ‚gaux … i
for (i=1;i<k+1;i++) tab3[i] =tab3[i] +tab3[i-1];
//tab3[i] contient … pr‚sent le nombre d'‚lts inf‚rieurs ou ‚gaux … i
for (j = longueur-1 ; j >-1 ; j--)
{
tab2[tab3[tab[j]]-1] = tab[j];
tab3[tab[j]]--;
}
}
//**************************************************************************************************************************************
// fonction affichage entete
//**************************************************************************************************************************************
void affiche_entete( char * titre )
{
clrscr();
printf("NNAS*************************************************************************************************************************************************************************************** ");
textcolor(14 + 128 );
cprintf("| %s |",titre);
// delay(2000);
textcolor(15);
printf("**********************************************************************************************************************************************************************************************NNAS\n");
}
//**************************************************************************************************************************************
// fonction affichage menu accueil
//**************************************************************************************************************************************
void accueil(void)
{
printf(" \n \n \n \n \n\n\n\n\n");
printf(" ******************************************* \n");
printf(" * * \n");
printf(" * 1 TRIS PAR SELECTION * \n");
printf(" * * \n");
printf(" * * \n");
printf(" * 2 TRIS PAR INSERTION * \n");
printf(" * * \n");
printf(" * * \n");
printf(" * 3 TRIS PAR DENOMBREMENT * \n");
printf(" * * \n");
printf(" * * \n");
printf(" * 4 TRIS RAPIDE * \n");
printf(" * * \n");
printf(" * * \n");
printf(" * 5 COMPARAISON DES TRIS * \n");
printf(" * * \n");
printf(" * * \n");
printf(" * 0 EXIT * \n");
printf(" * * \n");
printf(" ******************************************* \n");
printf(" \n \n \n \n ");
}
//*************************************************************************************************************************
// proc‚dure simule pour la pr‚miere page
void simule(void)
{
clrscr();
textcolor(15);
printf(" \n \n \n \n \n\n\n\n\n");
printf(" \n \n \n \n \n\n\n\n\n");
printf("****************************************************************************** \n");
printf(" \n \n \n \n \n\n\n\n\n");
printf(" Ce programme permet de comparer la complexit‚ des differents algorithmes de tri \n");
printf(" \n\n");
printf(" il a ‚t‚ ‚crit par : ");
textcolor(15 + 128);
cprintf(" NNAS ");
printf(" \n \n \n \n \n\n\n\n\n");
printf("********************************************************************************");
}
//*************************************************************************************************************************************************************************
// Nom qui clignote
void clignote(int M)
{ // M temps d'un delay
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf("NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
printf(" NTCHANA NYAMSI ARLAIS");
delay(M);
clrscr();
textcolor(15+128);
printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
cprintf(" NTCHANA NYAMSI ARLAIS");
delay(M);
}
//*************************************************************************************************************************************************************************************
//
// DEBUT DU PROGRAMME PRINCIPAL
//
//*************************************************************************************************************************************************************************************
void main()
{char * titre;
simule();
getch();
clignote(700);
textcolor(15);
getch();
do{
clrscr();
titre= "MENU PRINCIPAL";
affiche_entete(titre);
accueil();
printf(" Votre choix : ");
scanf("%d",&choix);
// choix=getchar();
switch(choix)
{
case 1:
{
clrscr();first = 0;second = 0;
titre= " SELECTION ";
affiche_entete(titre);
printf(" \n \n \n");
// printf("Le tri par insertion est un algorithme efficace quand il s'agit de trier \n \nun petit nombre d'‚l‚ments ");
printf("\n\n");
// printf("Le temp d'‚x‚cution dans le pire des cas est en O(ný)");
// getch();
clrscr();
titre= " SELECTION ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Entrer la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );
printf(" \n\n");
printf("Taille : ");
// longueur = getchar();
scanf("%d",&longueur);
// printf(" le max est %d ",longueur);
//getch();
generervecteur(tab,longueur);
clrscr();
titre= " SELECTION ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau avant le tri \n \n \n");
affiche(tab,longueur);
getch();
first = clock();
TRI_SELECTION(tab);
second = clock();
// clrscr();
// titre= " SELECTION ";
// affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);
getch();
printf(" \n");
printf("Le tableau tri‚ : \n");
printf("\n\n\n");
affiche(tab,longueur);
getch();
} break;
case 2:
{
clrscr(); first = 0;second = 0;
titre= " INSERTION ";
affiche_entete(titre);
printf(" \n \n \n");
printf("Le tri par insertion est un algorithme efficace quand il s'agit de trier \n \nun petit nombre d'‚l‚ments ");
printf("\n\n");
printf("Le temp d'‚x‚cution dans le pire des cas est en O(ný)");
getch();
clrscr();
titre= " INSERTION ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Entrer la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );
printf(" \n\n");
printf("Taille : ");
// longueur = getchar();
scanf("%d",&longueur);
// printf(" le max est %d ",longueur);
// getch();
generervecteur(tab,longueur);
clrscr();
titre= " INSERTION ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau avant le tri \n \n \n");
affiche(tab,longueur);
getch();
first = clock();
TRI_INSERTION(tab,longueur);
second = clock();
// clrscr();
// titre= " INSERTION ";
// affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);
getch();
printf(" \n");
printf("Le tableau tri‚ : \n");
printf("\n\n\n");
affiche(tab,longueur);
getch();
} break;
case 3:
{
clrscr(); first = 0;second = 0;
titre= " DENOMBREMENT ";
affiche_entete(titre);
printf(" \n \n \n");
printf("Le principe du tri par d‚nombrement est de d‚terminer \n\npour chaque ‚lt x de l'entr‚e, le nombre d'‚lts inf‚rieurs … x.\n\nCette information peut sevir … placer l'‚lt x directement … sa position \n\ndans le tableau de sortie \n\nCe tri s'‚x‚cute en O(n) lorsque le plus grand\n\n‚lt k est tel que k=O(n)");
printf("\n\n");
getch();
clrscr();
titre= " DENOMBREMENT ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Entrer la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );
printf(" \n\n");
printf("Taille : ");
// longueur = getchar();
scanf("%d",&longueur);
// printf(" le max est %d ",longueur);
// getch();
generervecteur(tab,longueur);
clrscr();
titre= " DENOMBREMENT ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau avant le tri \n \n \n");
affiche(tab,longueur);
getch();
k = CHERCHEMAX ( tab , longueur);
first = clock();
TRI_DENOMBREMENT(tab,vect,k);
second = clock();
// clrscr();
// titre= " DENOMBREMENT ";
// affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);
getch();
printf(" \n");
printf("Le tableau tri‚ : \n");
printf("\n\n\n");
affiche(vect,longueur);
getch();
} break;
case 4:
{
clrscr(); first = 0;second = 0;
titre= " RAPIDE ";
affiche_entete(titre);
printf(" \n \n \n");
printf("Le tri rapide est un algo bas‚ sur le paradigme \" diviser pour regner \" \n \nSon temps d'‚x‚cution dans le pire des cas est O(ný). \n \nPar contre il est souvent le meilleur choix en pratique,\n\n… cause de son efficacit‚ remarquable en moyenne : son temps d'‚x‚cution \n\nattendu est O(nln n)");
printf("\n\n");
getch();
clrscr();
titre= " RAPIDE ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Entrer la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );
printf(" \n\n");
printf("Taille : ");
// longueur = getchar();
scanf("%d",&longueur);
// printf(" le max est %d ",longueur);
// getch();
generervecteur(tab,longueur);
clrscr();
titre= " RAPIDE ";
affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau avant le tri \n \n \n");
affiche(tab,longueur);
getch();
first = clock();
TRI_RAPIDE(tab,0,longueur);
second = clock();
// clrscr();
// titre= " RAPIDE ";
// affiche_entete(titre);
printf(" \n\n\n\n");
printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);
getch();
printf(" \n");
printf("Le tableau tri‚ est le suivant : \n");
printf("\n\n\n");
affiche(tab,longueur);
getch();
} break;
case 5:
{
clrscr();
titre= "COMPARAISON DES TRIS";
affiche_entete(titre);
printf("-------------------------------------------------------------------------------\n");
printf("|");
textcolor(7);
cprintf("Taille"); printf(" |");
cprintf("Tri selection"); printf(" |");
cprintf("Tri insertion"); printf(" |");
cprintf(" Tri rapide"); printf(" |");
cprintf("Tri denombrement"); printf(" |\n");
textcolor(15);
printf("-------------------------------------------------------------------------------\n");
longueur = 100;
do
{
printf(": ");
///////////////////////////////////////////////////////////////
generervecteur(tab,longueur); recopie(tab,vect,longueur);
///////////////////////////////////////////////////////////////
//********************************************************************************************
// TRIS PAR SELECTION
first = 0;second = 0;
first =clock(); /* Gets system time */
TRI_SELECTION(vect);
second = clock(); /* Gets system time again */
printf("%4d : %-6e :",longueur,(1000*second - 1000*first) / CLK_TCK);
//********************************************************************************************
///////////////////////////////////////////
recopie(tab,vect,longueur);
//////////////////////////////////////////
//********************************************************************************************
// TRIS PAR INSERTION
first = 0;second = 0;
first = clock();
TRI_INSERTION( vect,longueur);
second = clock();
printf(" %-6e :",(1000*second - 1000*first)/CLK_TCK);
//********************************************************************************************
///////////////////////////////////////////
recopie(tab,vect,longueur);
//////////////////////////////////////////
//********************************************************************************************
// TRIS RAPIDE
first = 0;second = 0;
first = clock();
TRI_RAPIDE(vect,0,longueur);
second = clock();
printf(" %-6e :",(1000*second - 1000*first)/CLK_TCK);
//********************************************************************************************
///////////////////////////////////////////
recopie(tab,vect,longueur);
//////////////////////////////////////////
k=CHERCHEMAX(vect,longueur);
//********************************************************************************************
// TRIS PAR DENOMBREMENT
first = 0;second = 0;
first = clock();
TRI_DENOMBREMENT (vect,tab,longueur);
second = clock();
printf(" %-6e :",(1000*second - 1000*first) / CLK_TCK);
// printf(" %-6e :",(1000*second - 1000*first)/CLK_TCK);
printf("\n");
printf("-------------------------------------------------------------------------------\n");
//********************************************************************************************
longueur +=pas;
}
while(longueur<N);
getch();
} break;
case 0: choix = 0;break;
}
} while(choix != 0);
}

//**********************************************************************************
// Ce programme permet de comparer la complexit‚ des differents algorithmes de tris
//	       il a été  écrit par NTCHANA NYAMSI ARLAIS
//**********************************************************************************



#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<time.h>
#define N 4000


// nos d‚clarations

int k,choix;

int tab[N],vect [N];

int longueur = 100;

int pas=200;  // déclaration du pas

clock_t first, second; //Mesure du temps



//*******************************************************************************
//				procédure affiche
//		Permet d'afficher les valeurs du tableau
//	(on vérifie avec cette proc‚dure que le tableau est bien tri‚)
//****************************************************************************************************

void affiche(int t[N],int max)

{

int m;

//clrscr();

for (m=0; m<max;m++) printf(" %4d",t[m]);

//getch();

}
//*************************************************************************************************
//                          proc‚dure generervecteur
//   Elle permet de remplir de maniŠre al‚atoire max +1 case d'un tableau de N ‚l‚ments
//*************************************************************************************************

void generervecteur(int tab[N],int longueur)

{
	int i;

	randomize();

	for( i=0;i<longueur;i++)
	{
	 tab[i]= /*i+1;*/ rand() % longueur;
	}


}

//*************************************************************************************************
//                          procédure recopie
//     Cette fonction permet de faire la copie d'un tableau … un autre
//*************************************************************************************************

void recopie(int tab[N],int vect[N],int longueur)

{int i;
 for(i=0;i<longueur+1;i++)  vect[i]=tab[i];

}



//********************************************************************************************************
//                          procédure tris_rapide
//
// Le tri rapide est un algo bas‚ sur le paradigme "diviser pour regner" son temps d'‚x‚cution dans le pire
// des cas est O(ný). Par contre il est souvent le meilleur choix en pratique, … cause de son efficacit‚
//	remarquable en moyenne : son temps d'‚x‚cution attendu est O(nln n)
//
//********************************************************************************************************

/**************** Ecriture de la proc‚dure PARTITIONNER ******************************/

int PARTITIONNER (int tab[],int p,int r)
{
int i,j,x,temp,vrai = 1;

	x = tab[p];

	i = p-1;

	j = r+1;

	while (vrai/*vrai !=0*/)
		{
		do j --; while ( tab[j] > x );

		do i++ ;while(tab[i] < x);

		if (i<j)
			{
			temp 	 = tab[i];

			tab[i] = tab[j];

			tab[j] = temp	;
			}
		else
			{
			vrai = 0;

			return(j);

			}
		}
return(j);
}

//*********************** Ecriture de la proc‚dure TRI RAPIDE *****************************************

void TRI_RAPIDE (int tab[N], int p ,int r)
{

	int q;

	if ( p < r )
		{
		 q = PARTITIONNER (tab,p,r);

		 TRI_RAPIDE (tab, p, q);

		 TRI_RAPIDE (tab, q+1, r);

		}
}



//*************************************************************************************************
//                          proc‚dure TRI PAR INSERTION
//
// Le tri par insertion est un algorithme efficace quand il s'agit de trier un petit nombre d'‚l‚ments
// Le temp d'‚x‚cution dans le pire des cas est en O(n2)
//*************************************************************************************************


void TRI_INSERTION(int tab[],int longueur)
	{
	  int j, cle, compt, vrai;

	  for(j=1;j<longueur;j++)
		{

			cle=tab[j];

			//insertion de tab[j] dans la s‚quence tri‚e tab[0..j-2]

			compt=j-1;

			do
			{
				vrai=0;

				if (tab[compt]>cle)

					 {

					 tab[compt+1]=tab[compt];

					 compt--;

					 vrai=1;

					 }
				if (compt<0) vrai=0;

			}
		  while(vrai);

		  tab[compt+1]=cle;

	}

}
//*************************************************************************************************
//                          proc‚dure tris 	par selection
//************************************************************************************************

void TRI_SELECTION(int tab[N])
{
int t[N],k,temp,i,j;

	for(i=0;i<longueur;i++)

	 {
		k=i;

		for(j=i+1;j<longueur;j++)
		 {
			if(tab[j]<tab[k]) k=j;
		 }
		temp=tab[i];

		tab[i]=tab[k];

		tab[k]=temp;
	 }

};

//*************************************************************************************************
//                          proc‚dure TRI PAR DENOMBREMENT
//
//	Le principe du tri par d‚nombrement est de d‚terminer pour chaque ‚lt x de l'entr‚e, le nombre
//	d'‚lts inf‚rieurs … x. Cette information peut sevir … placer l'‚lt x directement … sa position
//	dans le tableau de sortie
// ce tri s'‚x‚cute en O(n) lorsque le plus grand ‚lt k est tel que k=O(n)
//*************************************************************************************************


//************************ Algorithme qui recherche le max du tableau ******************************************

int CHERCHEMAX ( int tab[], int longueur)

{int i, temp = 0;

	for (i=0; i<longueur; i++)

		if (tab[i] > temp )

			temp = tab[i];

	return(temp);
}

//************************ Proc‚dure TRI PAR DENOMBREMENT ******************************************

void TRI_DENOMBREMENT (int tab[],int tab2[],int k)

//tab[] tableau non tri‚; tab2[] tableau qui au sortir de la proc‚dure sera tri‚; k plus grand entier

{int tab3[N]; int i,j;


	for ( i=0; i<k+1; i++) tab3[i]=0;

	for (j=0; j<longueur;j++)  tab3[tab[j]]++;

	// tab3[i] contient … pr‚sent le nombre d'‚lt ‚gaux … i

	for (i=1;i<k+1;i++) tab3[i] =tab3[i] +tab3[i-1];

	//tab3[i] contient … pr‚sent le nombre d'‚lts inf‚rieurs ou ‚gaux … i

	for (j = longueur-1 ; j >-1 ; j--)
		{


			tab2[tab3[tab[j]]-1] = tab[j];

			tab3[tab[j]]--;

		}


}

//**************************************************************************************************************************************
//                   fonction affichage entete
//**************************************************************************************************************************************

void affiche_entete( char * titre )
{
	clrscr();
	printf("NNAS*************************************************************************************************************************************************************************************** ");

	textcolor(14 + 128 );
	cprintf("| %s |",titre);
  //	delay(2000);
	textcolor(15);


	printf("**********************************************************************************************************************************************************************************************NNAS\n");



}

//**************************************************************************************************************************************
//                   fonction affichage menu accueil
//**************************************************************************************************************************************

void accueil(void)
{
	printf(" \n \n \n \n \n\n\n\n\n");
	printf("		 *******************************************	\n");
	printf("		 * 				           *	\n");
	printf("		 *	1	TRIS PAR SELECTION         *	\n");
	printf("		 * 					   *	\n");
	printf("		 * 					   *	\n");
	printf("		 *	2	TRIS PAR INSERTION 	   *	\n");
	printf("		 * 					   *	\n");
	printf("		 * 					   *	\n");
	printf("		 *	3	TRIS PAR DENOMBREMENT      *	\n");
	printf("		 * 					   * \n");
	printf("		 *                                         *	\n");
	printf("		 *	4	TRIS RAPIDE 		   *	\n");
	printf("		 * 	                		   *	\n");
	printf("		 * 	                		   *	\n");
	printf("		 *	5	COMPARAISON DES TRIS	   *	\n");
	printf("		 * 	                		   *	\n");
	printf("		 * 	                		   *	\n");
	printf("		 *	0	EXIT	       		   *	\n");
	printf("		 * 	                		   *	\n");
	printf("		 ******************************************* \n");

	printf(" \n \n \n \n ");


}

//*************************************************************************************************************************
//									proc‚dure simule   pour la pr‚miere page

void simule(void)

{

	clrscr();

	textcolor(15);

	printf(" \n \n \n \n \n\n\n\n\n");

	printf(" \n \n \n \n \n\n\n\n\n");

	printf("****************************************************************************** \n");

	printf(" \n \n \n \n \n\n\n\n\n");

	printf(" Ce programme permet de comparer la complexit‚ des differents algorithmes de tri \n");

	printf(" \n\n");

	printf(" il a ‚t‚  ‚crit par :  ");

	textcolor(15 + 128);

	cprintf(" NNAS ");

	printf(" \n \n \n \n \n\n\n\n\n");

	printf("********************************************************************************");




}


//*************************************************************************************************************************************************************************
//   									Nom qui clignote

void clignote(int M)

{  // M temps d'un delay

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf(" NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("  NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("   NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("    NTCHANA NYAMSI ARLAIS");
	delay(M);



	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("     NTCHANA NYAMSI ARLAIS");
	delay(M);



	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("      NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("       NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("        NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("         NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("          NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("           NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("            NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("             NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("              NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("               NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                 NTCHANA NYAMSI ARLAIS");
	delay(M);



	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                  NTCHANA NYAMSI ARLAIS");
	delay(M);



	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                   NTCHANA NYAMSI ARLAIS");
	delay(M);


	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                    NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                     NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                      NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                       NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	printf("                        NTCHANA NYAMSI ARLAIS");
	delay(M);

	clrscr();
	textcolor(15+128);
	printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
	cprintf("                         NTCHANA NYAMSI ARLAIS");
	delay(M);


}

//*************************************************************************************************************************************************************************************
//
//									DEBUT DU PROGRAMME PRINCIPAL
//
//*************************************************************************************************************************************************************************************

void  main()
{char * titre;

	simule();
	getch();

	clignote(700);


	textcolor(15);


	getch();

	do{

	clrscr();

	titre= "MENU PRINCIPAL";
	affiche_entete(titre);

	accueil();

	printf(" Votre choix : ");

	scanf("%d",&choix);

  //	choix=getchar();

	switch(choix)

	{
	  case 1:
			{
				clrscr();first = 0;second = 0;

				titre= "  SELECTION  ";

				affiche_entete(titre);

				printf(" \n \n \n");

			  //	printf("Le tri par insertion est un algorithme efficace quand il s'agit de trier  \n \nun petit nombre d'‚l‚ments ");

				printf("\n\n");

			  //	printf("Le temp d'‚x‚cution dans le pire des cas est en O(ný)");

			  //	getch();

				clrscr();

				titre= "  SELECTION  ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Entrer  la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );

				printf(" \n\n");

				printf("Taille : ");

			  //	longueur = getchar();

				scanf("%d",&longueur);

			  //	printf(" le max est  %d ",longueur);

				//getch();

				generervecteur(tab,longueur);

				clrscr();


				titre= "  SELECTION  ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau avant le tri  \n \n \n");

				affiche(tab,longueur);

				getch();

				first = clock();

				TRI_SELECTION(tab);

				second = clock();

			  //	clrscr();


			 //	titre= "  SELECTION  ";

			//	affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);

				getch();

				printf(" \n");

				printf("Le tableau tri‚ : \n");

				printf("\n\n\n");

				affiche(tab,longueur);

				getch();

				}	break;
	  case 2:
				{

				clrscr();    first = 0;second = 0;

				titre= "  INSERTION  ";

				affiche_entete(titre);

				printf(" \n \n \n");

				printf("Le tri par insertion est un algorithme efficace quand il s'agit de trier  \n \nun petit nombre d'‚l‚ments ");

				printf("\n\n");

				printf("Le temp d'‚x‚cution dans le pire des cas est en O(ný)");

				getch();

				clrscr();

				titre= "  INSERTION  ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Entrer  la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );

				printf(" \n\n");

				printf("Taille : ");

			  //	longueur = getchar();

				scanf("%d",&longueur);

			  //	printf(" le max est  %d ",longueur);

			  //	getch();

				generervecteur(tab,longueur);

				clrscr();


				titre= "  INSERTION  ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau avant le tri  \n \n \n");

				affiche(tab,longueur);

				getch();

				first = clock();

				TRI_INSERTION(tab,longueur);

				second = clock();

			 //	clrscr();


		  //		titre= "  INSERTION  ";

		  //		affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);

				getch();

				printf(" \n");

				printf("Le tableau tri‚  : \n");

				printf("\n\n\n");

				affiche(tab,longueur);

				getch();

				}  break;
	  case 3:

				{
				 clrscr();  first = 0;second = 0;

				titre= " DENOMBREMENT ";

				affiche_entete(titre);

				printf(" \n \n \n");

				printf("Le principe du tri par d‚nombrement est de d‚terminer \n\npour chaque ‚lt x de l'entr‚e, le nombre  d'‚lts inf‚rieurs … x.\n\nCette information peut sevir … placer l'‚lt x directement … sa position \n\ndans le tableau de sortie \n\nCe tri s'‚x‚cute en O(n) lorsque le plus grand\n\n‚lt k est tel que k=O(n)");

				printf("\n\n");


				getch();

				clrscr();

				titre= " DENOMBREMENT ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Entrer  la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );

				printf(" \n\n");

				printf("Taille : ");

			  //	longueur = getchar();

				scanf("%d",&longueur);

			  //	printf(" le max est  %d ",longueur);

			  //	getch();

				generervecteur(tab,longueur);

				clrscr();


				titre= " DENOMBREMENT ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau avant le tri  \n \n \n");

				affiche(tab,longueur);

				getch();

				k = CHERCHEMAX ( tab , longueur);

				first = clock();


				TRI_DENOMBREMENT(tab,vect,k);

				second = clock();

			//	clrscr();


		 //	titre= " DENOMBREMENT ";

		 //	affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);

				getch();

				printf(" \n");

				printf("Le tableau tri‚  : \n");

				printf("\n\n\n");

				affiche(vect,longueur);

				getch();


				}	break;
	  case 4:

				{

				clrscr();   first = 0;second = 0;

				titre= "  RAPIDE  ";

				affiche_entete(titre);

				printf(" \n \n \n");

				printf("Le tri rapide est un algo bas‚ sur le paradigme \" diviser pour regner \"  \n \nSon temps d'‚x‚cution dans le pire des cas est O(ný). \n \nPar contre il est souvent le meilleur choix en pratique,\n\n… cause de son efficacit‚ remarquable en moyenne : son temps d'‚x‚cution \n\nattendu est O(nln n)");

				printf("\n\n");

				getch();

				clrscr();

				titre= "  RAPIDE  ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Entrer  la taille du tableau et nous allons le remplir de fa‡on al‚atoire \n \n" );

				printf(" \n\n");

				printf("Taille : ");

			  //	longueur = getchar();

				scanf("%d",&longueur);

			  //	printf(" le max est  %d ",longueur);

			  //	getch();

				generervecteur(tab,longueur);

				clrscr();


				titre= "  RAPIDE  ";

				affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau avant le tri  \n \n \n");

				affiche(tab,longueur);

				getch();

				first = clock();

				TRI_RAPIDE(tab,0,longueur);

				second = clock();

		  //	clrscr();


		 //	titre= "  RAPIDE  ";

		 //	affiche_entete(titre);

				printf(" \n\n\n\n");

				printf("Le tableau … ‚t‚ tri‚ en %f ms \n", (1000*second - 1000* first) / CLK_TCK);

				getch();

				printf(" \n");

				printf("Le tableau tri‚ est le suivant : \n");

				printf("\n\n\n");

				affiche(tab,longueur);

				getch();


				}	break;
	  case 5:

				{
				clrscr();

				titre= "COMPARAISON DES TRIS";

				affiche_entete(titre);

				printf("-------------------------------------------------------------------------------\n");
				printf("|");
				textcolor(7);
				cprintf("Taille"); printf("  |");
				cprintf("Tri  selection"); printf(" |");
				cprintf("Tri  insertion"); printf(" |");
				cprintf("  Tri  rapide"); printf("   |");
				cprintf("Tri  denombrement"); printf("  |\n");
				textcolor(15);
				printf("-------------------------------------------------------------------------------\n");

				longueur = 100;

				do
					{
						printf(": ");

					///////////////////////////////////////////////////////////////
							generervecteur(tab,longueur); recopie(tab,vect,longueur);
					///////////////////////////////////////////////////////////////

//********************************************************************************************
//										TRIS PAR SELECTION

				first = 0;second = 0;
				first =clock(); /* Gets system time  */
				TRI_SELECTION(vect);
				second = clock(); /* Gets system time again */
				printf("%4d   : %-6e  :",longueur,(1000*second - 1000*first) / CLK_TCK);

//********************************************************************************************


					///////////////////////////////////////////
								recopie(tab,vect,longueur);
					//////////////////////////////////////////


//********************************************************************************************
//									TRIS PAR INSERTION

				first = 0;second = 0;
				first = clock();
				TRI_INSERTION( vect,longueur);
				second = clock();
				printf("  %-6e :",(1000*second - 1000*first)/CLK_TCK);

//********************************************************************************************


					///////////////////////////////////////////
							recopie(tab,vect,longueur);
					//////////////////////////////////////////



//********************************************************************************************
//									  TRIS RAPIDE

				first = 0;second = 0;
				first = clock();
				TRI_RAPIDE(vect,0,longueur);
				second = clock();
				printf("  %-6e  :",(1000*second - 1000*first)/CLK_TCK);


//********************************************************************************************


					///////////////////////////////////////////
							recopie(tab,vect,longueur);
					//////////////////////////////////////////

					 k=CHERCHEMAX(vect,longueur);

//********************************************************************************************
//									  TRIS PAR DENOMBREMENT

				first = 0;second = 0;
				first = clock();
				TRI_DENOMBREMENT (vect,tab,longueur);
				second = clock();
				printf("   %-6e    :",(1000*second - 1000*first) / CLK_TCK);
		 //		printf("   %-6e   :",(1000*second - 1000*first)/CLK_TCK);
				printf("\n");


				printf("-------------------------------------------------------------------------------\n");
//********************************************************************************************


		longueur +=pas;
	}
	while(longueur<N);

	getch();

				}	break;
	case 0:  choix = 0;break;

	}

	} while(choix != 0);
}

Conclusion

Je me suis inspiré des manuels d'algorithmes pour sortir ces differets codes! jusqu'a present je suis à peu près sûr
que tous mes tris marchent excepté le tris rapide ou il y'a un décalage d'indice!

Si quelqu'un trouve la faille, prière de m'écrire à stephanearlais@yahoo.fr

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

TRI~COM.C 23 659 octets

Télécharger le zip

Sources de la même categorie

PROGRAMME DE SUDOKU par AffreuxJojp

EVALUATEUR D'EXPRESSION ARITHMÉTIQUE par matrx180vTitanium

QBIBLIO GESTION DES PRÊTS par conatic

QL-CHATROOM V 1.0 par mature

GEOLOCALISATION par ganjarasta

Toutes les sources de la catégorie Application

Sources en rapport avec celle ci

COMPARATIF DES TRIS QUADRATIQUE par gnairod

LE QUICKSORT NON-RECURSIF ET L'IMPACT DE L'INSERTIONSORT SUR... par nickydaquick

TRI PAR INSERTION AVEC SENTINELLE par AlexN

QUICKSORT - NON RECURSIF par nickydaquick

CSORTEDARRAY<TEMPLATE> VISUAL C++ MFC par shenron666

Commentaires et avis

Commentaire de vecchio56 le 09/12/2005 17:59:45 administrateur CS

C'est dommage de s'attarder autant sur des choses inutiles, comme la couleut du texte.
Peux-tu par exemple expliquer à quoi sert la fonction clignote qui fait je sais pas combien de lignes?

Pour le code des algo, certains dépendent tous de N, je pense qu'il faudrait enlever cela

Commentaire de magma le 09/12/2005 19:27:12

La fonction Clignote() est longue
parce qu'elle va clignoter 26 fois !

Commentaire de vecchio56 le 09/12/2005 19:34:42 administrateur CS

Bien sur, et les boucles tu connais pas?

Commentaire de juki_webmaster le 09/12/2005 19:49:24

C'est vraiment important de faire clignoter du texte pendant qu'ont fait du trie ?

Commentaire de NNAS le 11/12/2005 22:24:36

Je suis conscient du fait que l'éfficacité passe avant le design! Mais un travail pas beau du tout ne vaut pas
un clou!Je me suis rendu compte que ce qui plait à l'utilisateur courant,c'est beaucoup plus la beauté...
C'est la raison pour laquelle j'essai autant que faire ce peut d'associer efficacité et design!
Et la fonction clignote donne un certain effet au programme.

Commentaire de Cyberboy2054 le 14/12/2005 20:19:38

Je veux pas faire le rabat joie, mais la console, tu peux la faire clignoter que tu veux, elle restera toujours moche :/
(oui je sais, t'as pas encore dépassé le stade de la console mais peu importe)
Par contre si tu veux progresser de manière utile, remplace cette infame fonction clignotte par,
for (int i = 0; i < 26;i++)
{
     clrscr();
     textcolor(15);
     printf(" \n \n \n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n");
     printf(" NTCHANA NYAMSI ARLAIS");
     delay(M);
}
Mais bon, c'est toujours pas ca :/
Sinon, plutot que de sauter une ligne entre chaque fonction, découpe ton programme en d'autres sous fonctions aux noms explicites ( genre lecture_tableau(), affiche_menu(), etc... )
comme ca tu gagneras en clarté

Commentaire de jean84 le 16/12/2005 10:54:01

La demarche pour l'utilisateur est interessante mais ne doit pas se faire au detriment des codeurs qui sont les premiers vises et plus particulierment sur ce site....
on se dit sa surtout quand on voit ta fonction clignote() ...
Pour l'areation du code, c'est tres important et tres bien d'avoir cette notion en tete et de l'appliquer, mais il faut faire attention de ne pas enrumer quelqu'un avec un trop plein d'air !!! ;-)
Si jamais tu souhaite quand meme faire une belle presentation (ce qui est normal), regarde du cote de devcpp qui creer lui meme le squelette d'une application win32 et si tu veux garder un code portable, ba t'as qu'a taper dans le wxWindows qui est pas trop compliquer a digerer ou meme Qt qui est a mon avis encore plus simple.... regarde mes sources tu verras 2 exemples de bases d'utilisation de cette lib (frames, boutons, gestionnaire d'action, ...) et il y en a encore d'autre sur ce site.
Cela te permettra un code vachment plus sympa a regarder et qui aura un interet tout autre.... :-)

@++ et bon coding !

Commentaire de NNAS le 22/12/2005 19:57:05

Merci de vos remarque les gars! ça me permet de mieux m'appliquer dans mes codes!
C'est vrai qu'a la limite elles sont choquantes, mais c'est indispensable:C'est à ça qu'on
reconnait des bons codeurs!

Commentaire de aytone85 le 02/02/2006 19:27:15

Salut, je suis en train de me pencher sur les tris en ce moment et je suis tombé sur ta source, je m'interesse plus particulièrement au tri rapide.
Je ne sais pas si tu as trouvé ton erreur pour le décalage d'indice, mais le gros point fort du tri rapide est le pivot. Tu intègres pourtant dans ton code la position du pivot mais tout est fait comme si il etait forcément en première position, ton code ne marche donc pas dans toutes les situations. Une petite modif suffit, lorsque tu choisis ton pivot, tu le change de place avec le premier élément du tableau et tu commence ta partition du tableau après le pivot. il te suffit ensuite de replacer le pivot entre tes deux partitions. C'est une solution mais il en existe plein. Je pense que celle ci fonctionne, je ne l'ai pas testé mais sur papier ça a l'air de fonctionner, mais surtout tu as le choix du pivot sur la premiere  partition, ça peut accelerer le calcul si sil est bien choisi (ex: pivot = valeur la plus proche de la valeur moyenne de tous le tableau).

void Echange (int Tab[], inti, int j)
{
    int Temp = Tab[i] ;
    Tab[i] = Tab[j] ;
    Tab[j] = Temp ;
}

void TriRapide(int Tab[],int Debut, int p, int Fin)
{
    int i, j, Temp, ValPivot = Tab[p] ;
    if (Fin <= Debut) return() ;
    if (p != Debut) Echange (Tab, p, Debut) ;
    i = Début ;
    j = Fin +1 ;
    Do
    {
        while ((Tab[++i] < ValPivot) && (i <= Fin)) ;
        while ((Tab[--j] > ValPivot) && (j > Debut)) ;
        if (i < j) Echange(Tab, i, j) ;
    }
    while(i < j) ;
    Echange(Tab, j, Debut)
    TriRapide(Tab, Debut, Debut, j-1) ;
    TriRapide(Tab, j+1, j+1, Fin) ;
}

A bientôt et si tu testes cette version, dis moi si ça marche !

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

encore un pb en c svp....... [ par natacha86 ] j'ai essayer de séparer les fonctions mais ca ne marche pas...#include <conio.h>#include <stdio.h>#include <string.h>#include & tri rapide (quicksort) et/ou tri par tas(heapsort) urgent [ par mersniyassine ] je trouve une difficulté a simuler graphiquement en C ces 2 trisya t-il quelqu'un qui peut me fournir un code.c compilable sur Turbo C qui effectue u tri par insertion dans une liste chaînée [ par titi4659 ] Bonjour,j'ai un problème avec une liste chaînée.j'ai une liste d'element que j'arrive a récupéré mais je souhaiterai que lorsque je récupère un elemen Tri par insertion sur listes simplement chainées [ par ichigoZ710 ] Bonjour, voilà, je vous explique rapidement mon problème, je dois élaborer une procédure de tri par insertion sur une liste qui vient en paramètre de tri insertion langage C et appel de fonction [ par washh ] Bonjour,Je débute en langage C et j'ai écrit l'algorithme du tri d'un tableau contenant des chaines de caractères, mais dès la compilation, le program tri alphabétique ultra rapide de chaines de caractères de longueur variable [ par mslider ] -- Bonjour, je sais que c'est un forum dédié au C mais je vais parler de pascal. En effet je connais bien ce langage et je l'ai utilisé pour trier a Tri par insertion sur liste simplement chainée [ par Jordy89 ] Bonjour,Dans le cadre de la manipulation d'une liste chaînée, je suis amené à effectuer un tri; Je me suis renseigné à gauche et à droite, et il appar tri rapide(quicksort)+tri par tas(heapsort)+simulation graphique [ par mersniyassine ] mon stage d'ete comporte une simulation graphique du tri par tas et du tri rapide, je trouve une difficulté a gerer le code source,merci bien de me fo Evenement trop rapide [ par larion ] Bonjour,Imaginons que nous avons 2 événements, pour exemple :evenement1: WM_LBUTTONDOWN --> Action1evenement2: WM_LBUTTONUP --> Action2S scripte d'une requête d'insertion [ par benlac_o ] Bonjour, j'ecris un script shell, le but c'est d'inserer des valeurs dans une tables, comme vous pouvez le voire dans la requête ci-dessous, je veux i

Nos sponsors

Derniers Blogs

IMAGINE CUP 2012, MAKE A SIGN EN FINALE par junarnoalg

KINECT 1.5 IS OUT ! par Vko

LES ACTUALITéS DE LA SEMAINE SUR C2I.FR (14 MAI - 20 MAI) par richardc

REACTIVE EXTENSIONS : CONSOMMER DES SERVICES AVEC RX PARTIE 3, LES PIèGES à éVITER par Groc

SHAREPOINT BLOG SITE, PROBLèME D'ARCHIVES par junarnoalg

Forum

MATRICE TEMPLATE par hjr2610

SUPERVISION DE LA BATTERIE par romanticgirl

RE : OPENCV ET INTERFACE GRAPHIQUE VISUAL STUDIO par buno

RE : SAC A DOS par hadjkaddour

OPENCV ET INTERFACE GRAPHIQUE VISUAL STUDIO par ssaif

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Realisation d-une version 2 d-un site e-commerce existant sous prestashop-REPUBLICATION
Budget : 5 000€
Recherche Infogerance Serveur Debian Linux
Budget : 1 800€
Creation d-un site vitrine avec MagentO
Budget : 2 000€

Logiciels

sDEVIS-FACTURES vlPRO (8.1.0.3)
SDEVIS-FACTURES VLPRO (8.1.0.3)

sDEVIS-FACTURES vlPRO a été mis au point pour les particuliers, créateurs, entrepreneurs, artisa...

Cliquez pour télécharger sDEVIS-FACTURES vlPRO
974 Application Server (12.2.4.6)
974 APPLICATION SERVER (12.2.4.6)

Développez de puissantes applications dans un environnement de 'cloud computing', clusterisé, séc...

Cliquez pour télécharger 974 Application Server
vPicture (1.4.2.1)
VPICTURE (1.4.2.1)

Avec vPicture, hébergez vos images facilement et rapidement. vPicture est un utilitaire simple, ...

Cliquez pour télécharger vPicture
Easy-Planning (2.2.1.6)
EASY-PLANNING (2.2.1.6)

Easy-Planning permet de créer des plannings sous la représentation de diagrammes et est adapté au...

Cliquez pour télécharger Easy-Planning
COM-BACKUP (2.0)
COM-BACKUP (2.0)

COM-BACKUP est un logiciel de sauvegarde qui permet de planifier les sauvegardes de vos dossiers ...

Cliquez pour télécharger COM-BACKUP