Example #1
0
int main ()
{
    int cas;
    tableau *tab = NULL;
    tab = remplissage_tableau(tab);//remplissage d'un tableau
    affichage_tableau(tab);//affichage
    printf("------Comment voulez-vous procceder pour le tri du tableau ?!------\n"
           "1 - Pour un tri a bulles.\n"
           "2 - Pour un tri par selection.\n"
           "Votre reponse:");
    scanf("%d",&cas);
    switch (cas){
        case 1:   tri_bulleo(tab);//si 1 appliquer le tri a bulle
                  break;
        /*case 2:   tab = tri_incertion(tab);//si 2 appliquer le tri par incertion
                  break;*/
        case 2:   tri_selection(tab);//si 3 appliquer le tri par selection echange
                  break;
        /*case 4: tri_rapide(tab, 0, tab->dernier_elem);
                  break; */
    }
    return 0;
}
Example #2
0
   int main(int argn, char *argv[])
   {
      int type_data;
      int type_tri;
      int sauvegarde_tableau_initial;
      int sauvegarde_tableau_final;
      int affichage_tableaux;
      int n = 0;
      char *fichier_lecture_tableau_initial, *fichier_sauvegarde_tableau_initial, *fichier_sauvegarde_tableau_final;
      int *tab;
      int i;
   
   
      structSondes sondes = {0, 0, 0};
   
      if (argn == 1) 
      {
         aide(argv[0]);
         exit(1);
      }
   
      type_data = UNKNOWN;
      type_tri = UNKNOWN;
      sauvegarde_tableau_initial = FALSE;
      sauvegarde_tableau_final = FALSE;
      affichage_tableaux = FALSE;
   
      for ( i = 1; i < argn; i+=2 )
      {
      	// choix des données à trier et des sauvegardes éventuelles du tableau initial et final
         if (strcmp("-f", argv[i]) == 0)
         {
            fichier_lecture_tableau_initial = (char *) malloc(1 + strlen(argv[i+1]) * sizeof(char));
            strcpy(fichier_lecture_tableau_initial, argv[i+1]);
            type_data = FICHIER;
            continue;
         }
      
         if (strcmp("-si", argv[i]) == 0)
         {
            fichier_sauvegarde_tableau_initial = (char *) malloc(1 + strlen(argv[i+1]) * sizeof(char));
            strcpy(fichier_sauvegarde_tableau_initial, argv[i+1]);
            sauvegarde_tableau_initial = TRUE;
            continue;
         }
      
         if (strcmp("-sf", argv[i]) == 0)
         {
            fichier_sauvegarde_tableau_final = (char *) malloc(1 + strlen(argv[i+1]) * sizeof(char));
            strcpy(fichier_sauvegarde_tableau_final, argv[i+1]);
            sauvegarde_tableau_final = TRUE;
            continue;
         }
      
         if (strcmp("-a", argv[i]) == 0)
         {
            n = atoi(argv[i+1]);
            type_data = RANDOM;
            continue;
         }
      
         if (strcmp("-mc", argv[i]) == 0)
         {
            n = atoi(argv[i+1]);
            type_data = TRIE;
            continue;
         }
      
         if (strcmp("-pc", argv[i]) == 0)
         {
            n = atoi(argv[i+1]);
            type_data = TRIE_INVERSE;
            continue;
         }

      
       	// choix de l'algorithme de tri
         if (strcmp("-t", argv[i]) == 0)
         {
            if (strcmp("bulle_naif", argv[i+1]) == 0)
               type_tri = BULLE_NAIF;
            
            else if (strcmp("bulle_bool", argv[i+1]) == 0)
               type_tri = BULLE_BOOL;
            
            else if (strcmp("bulle_opt", argv[i+1]) == 0)
               type_tri = BULLE_OPT;
            
            else if (strcmp("selection", argv[i+1]) == 0)
               type_tri = SELECTION;
            
            else if (strcmp("insertion", argv[i+1]) == 0)
               type_tri = INSERTION;
            
            else if (strcmp("rapide", argv[i+1]) == 0)
               type_tri = TRIRAPIDE;
            	
            else 
            {
					printf("\n le tri demandé < %s >  n'existe pas \n", argv[i+1]);
               aide(argv[0]);
               exit(1);
            }
            continue;
         }

      
       	// choix de la visualisation (affichage) du tableau initial et final
         if (strcmp("-v", argv[i]) == 0)
         {
            affichage_tableaux = TRUE;
            i--;
            continue;
         }
      	
			printf("\n l'option demandée < %s >  n'existe pas \n", argv[i]);
         aide(argv[0]);	
			exit(1);
      }
   
   	if (n < 1) {
			printf("\n le nombre d'éléments à trier est incorrect : %d \n", n);
         aide(argv[0]);	
			exit(1);
		}
   
   
      switch(type_data)
      {
         case TRIE:
            {
               tab = data_triee(n);
               printf("Tableau initial trié (meilleur des cas)");
               break;
            }
         
         case TRIE_INVERSE:
            {
               tab = data_triee_inverse(n);
               printf("Tableau intial trié en ordre inverse (pire des cas)");
               break;
            }
         case FICHIER:
            {
               tab = f_lire_data(fichier_lecture_tableau_initial, &n);
               printf("Tableau initial lu dans %s", fichier_lecture_tableau_initial);
               break;
            }
         case RANDOM:
            {
               tab = random_data(n);
               printf("Tableau initial aléatoire");
               break;
            }
         case UNKNOWN:
            aide(argv[0]);
            exit(1);
      }
   
      if (sauvegarde_tableau_initial == TRUE)
         f_ecrire_data(fichier_sauvegarde_tableau_initial, tab, n);
   
   
      if (affichage_tableaux == TRUE) {
         printf("\n");
         ecrire_data(tab,  n);
      }
   
      switch(type_tri)
      {
         case BULLE_NAIF: 
            sondes = tri_bulle_naif(tab, n);
            if (affichage_tableaux == TRUE) {
               printf("Tableau trié (bulle naïf)\n");
               ecrire_data(tab,  n);
            }
            analyse_complexite(sondes, "bulle naïf", n);
            break;
         case BULLE_BOOL: 
            sondes = tri_bulle_bool(tab, n);
            if (affichage_tableaux == TRUE) {
               printf("Tableau trié (bulle bool)\n");
               ecrire_data(tab,  n);
            }
            analyse_complexite(sondes, "bulle bool", n);
            break;
         case BULLE_OPT: 
            sondes = tri_bulle_opt(tab, n);
            if (affichage_tableaux == TRUE) {
               printf("Tableau trié (bulle opt)\n");
               ecrire_data(tab,  n);
            }
            analyse_complexite(sondes, "bulle opt", n);
            break;
         case SELECTION:
            sondes = tri_selection(tab, n);
            if (affichage_tableaux == TRUE) {
               printf("Tableau trié (selection)\n");
               ecrire_data(tab,  n);
            }
            analyse_complexite(sondes, "selection", n);
            break;
         case INSERTION:
            sondes = tri_insertion(tab, n);
            if (affichage_tableaux == TRUE) {
               printf("Tableau trié (insertion)\n");
               ecrire_data(tab,  n);
            }
            analyse_complexite(sondes, "insertion", n);
            break;
         case TRIRAPIDE:
            sondes = tri_rapide(tab, 0, n-1);
            if (affichage_tableaux == TRUE) {
               printf("Tableau trié (rapide)\n");
               ecrire_data(tab,  n);
            }
            analyse_complexite(sondes, "rapide", n);
            break;
         case UNKNOWN:
            aide(argv[0]);
            exit(1);
      }
   
   
      if (sauvegarde_tableau_final == TRUE)
         f_ecrire_data(fichier_sauvegarde_tableau_final, tab, n);
   
      printf("\n");
      return 0;
   }
Example #3
0
/*

Procédure créant les fichiers contenant le nombre moyen d'affectations
et de comparaisons pour toutes les tailles pour un algorithme. La procédure
prend le choix du tri en paramètre ainsi que les noms des fichiers à créer.

*/
void statistiques(char typeTri, char* fichierAff, char* fichierComp){
	
	int sommeComp, sommeAff, moyenneComp, moyenneAff, i, j, comparaisons, affectations, taille;

	int tableau[10000];
	
	FILE* fichier1 = fopen(fichierAff, "w");
	FILE* fichier2 = fopen(fichierComp, "w");
	
	for(i=0;i<10;i++){
		taille = valeur[i];
		sommeComp=0;
		sommeAff=0;
		for(j=0;j<N;j++){			
			init_tab(tableau, taille);
			comparaisons = 0;
			affectations = 0;
			switch (typeTri) {
			
				case 'S':
					tri_selection(tableau,taille, &comparaisons, &affectations);
					break;
					
				case 'I':
					tri_insertion(tableau,taille, &comparaisons, &affectations);
					break;
					
				case 'B':
					tri_bulle(tableau,taille, &comparaisons, &affectations);
					break;
					
				case 'D':
					q_sort(tableau, 0, taille-1, PIVOT_DEBUT, &comparaisons, &affectations);
					break;		
					
				case 'F':
					q_sort(tableau, 0, taille-1, PIVOT_FIN, &comparaisons, &affectations);
					break;
					
				case 'M':
					q_sort(tableau, 0, taille-1, PIVOT_MEDIAN, &comparaisons, &affectations);
					break;
					
				case 'A':
					q_sort(tableau, 0, taille-1, PIVOT_RANDOM, &comparaisons, &affectations);
					break;	
			}

			
			sommeComp = sommeComp + comparaisons;
			sommeAff = sommeAff + affectations;
		}
		moyenneComp = sommeComp / N;
		moyenneAff = sommeAff / N;
		fprintf(fichier1, "%d %d\n", taille, moyenneAff);
		fprintf(fichier2, "%d %d\n", taille, moyenneComp);
	}
	fclose(fichier1);
	fclose(fichier2);
	printf("Enregistrement des statistiques terminé.\n");
}