.gitignore

+*.o
+triFusion
+triInsertion
+triRapide
+triFusionCompte
+triInsertionCompte
+triRapideCompte
+main
+*.gch

main.c

+#include "tris.h"
+
+int main(int argc,char** argv){
+
+}

makefile

+all: main triFusion triInsertion triRapide triFusion triFusionCompte triRapideCompte triInsertionCompte
+
+main: main.c tris.o utils.o
+	gcc -Wall -o $@ $^
+
+%.o: %.c
+	gcc -Wall -c $^
+
+%: %.c utils.o
+	gcc -Wall -o $@ $^

tp2/README.md

+# Questions que l'on se pose:
+
+* Pourquoi le tri insertion explose pour les tableaux aléatoires et décroissants, mais est constant pour les tableaux constants et croissants ?
+* Pourquoi le tri rapide n'est absolument pas rapide pour les tableaux constants,  croissants et décroissants ? Pourquoi rapide sur l'aléatoire ?
+* Est-ce que la croissance du tri fusion et du tri rapide pour les tableaux aléatoires sont équivalents ?
+* Pourquoi le tri fusion semble robuste en comparaison des deux autres tris ?
+
+# Graphe de comparaison des tris
+
+![](comparaison_tris.png)

tp2/main.c

+#include "triFusion.h"
+#include "triInsertion.h"
+#include "triRapide.h"
+
+int main(int argc,char** argv){
+	if(argc < 4){
+		printf("%s: usage: %s <tri> <typeTab> <longueur>\n",argv[0],argv[0]);
+		return 1;
+	}
+	size_t longueur = atol(argv[3]);
+	long* tab = malloc(longueur*sizeof(long));
+	if(!strcmp(argv[2],"de")){
+		tabDec(tab,longueur);
+	}else if(!strcmp(argv[2],"cr")){
+		tabCroi(tab,longueur);
+	}else if(!strcmp(argv[2],"co")){
+		tabConst(tab,longueur);
+	}else if(!strcmp(argv[2],"al")){
+		srand(time(NULL));
+		tabAlea(tab,longueur);
+	}else{
+		printf("\"%s\": type de tableau invalide (valides: de, cr, co, al)\n",argv[2]);
+		return 1;
+	}
+	if(argv[1][0] == 'f'){
+		triFusion(tab,longueur);
+	}else if(argv[1][0] == 'i'){
+		triInsertion(tab,longueur);
+	}else if(argv[1][0] == 'r'){
+		triRapide(tab,longueur);
+	}else{
+		printf("\"%s\": tri invalide (valides: f, i, r)\n",argv[1]);
+		return 1;
+	}
+}

tp2/makefile

+all: main
+
+main: main.c utils.o triFusion.o triInsertion.o triRapide.o
+	gcc -Wall -o $@ $^
+
+%.o: %.c
+	gcc -Wall -c $^
+
+%: %.c utils.o
+	gcc -Wall -o $@ $^

tp2/perf.R

+library(ggplot2)
+
+perf <- read.table("perf.dat",header=TRUE)
+
+###ggplot(perf,aes(x=taille,y=temps,color=tri,shape=typeTab)) + geom_point() + geom_line() + facet_grid(tri ~ typeTab) ###+ scale_y_log10()
+ggplot(perf,aes(x=taille,y=temps,color=tri)) + geom_line() + facet_grid(tri ~ typeTab)
+
+ggsave("comparaison_tris.png")

tp2/perf.sh

+#!/bin/bash
+
+echo -e "tri\ttypeTab\ttaille\ttemps\tmem"
+
+for tri in f r i;do
+	for typeTab in de cr co al;do
+		taille=1000000
+		while [ $taille -lt 10000000 ];do
+			for i in $(seq 1 3);do
+				#taille=$(( $(od -An -N4 -tu </dev/urandom) % 1000000 ))
+				res=$(timeout 3 /usr/bin/time -f "%U\t%M" ./main $tri $typeTab $taille 2>&1)
+				if [ $? -eq 124 ];then
+					res="NA\tNA"
+				fi
+				echo -e "$tri\t$typeTab\t$taille\t$res"
+			done
+		taille=$(($taille+1000000))
+		done
+	done
+done

tp2/perfOld.dat

+tri	typeTab	taille	temps	mem
+f	de	10	0.00	1240
+f	de	20	0.00	1268
+f	de	40	0.00	1284
+f	de	80	0.00	1252
+f	de	160	0.00	1288
+f	de	320	0.00	1324
+f	de	640	0.00	1280
+f	de	1280	0.00	1284
+f	de	2560	0.00	1276
+f	de	5120	0.00	1348
+f	de	10240	0.00	1468
+f	de	20480	0.00	1556
+f	de	40960	0.01	1908
+f	de	81920	0.01	2432
+f	de	163840	0.01	3708
+f	de	327680	0.04	6308
+f	de	655360	0.08	11408
+f	cr	10	0.00	1252
+f	cr	20	0.00	1316
+f	cr	40	0.00	1256
+f	cr	80	0.00	1316
+f	cr	160	0.00	1312
+f	cr	320	0.00	1208
+f	cr	640	0.00	1212
+f	cr	1280	0.00	1284
+f	cr	2560	0.00	1332
+f	cr	5120	0.00	1396
+f	cr	10240	0.00	1460
+f	cr	20480	0.00	1500
+f	cr	40960	0.00	1824
+f	cr	81920	0.01	2440
+f	cr	163840	0.02	3488
+f	cr	327680	0.03	6156
+f	cr	655360	0.08	11360
+f	co	10	0.00	1312
+f	co	20	0.00	1388
+f	co	40	0.00	1388
+f	co	80	0.00	1256
+f	co	160	0.00	1312
+f	co	320	0.00	1300
+f	co	640	0.00	1212
+f	co	1280	0.00	1304
+f	co	2560	0.00	1348
+f	co	5120	0.00	1392
+f	co	10240	0.00	1396
+f	co	20480	0.00	1608
+f	co	40960	0.00	1836
+f	co	81920	0.01	2404
+f	co	163840	0.02	3648
+f	co	327680	0.03	6264
+f	co	655360	0.08	11460
+f	al	10	0.00	1284
+f	al	20	0.00	1200
+f	al	40	0.00	1320
+f	al	80	0.00	1264
+f	al	160	0.00	1320
+f	al	320	0.00	1208
+f	al	640	0.00	1336
+f	al	1280	0.00	1408
+f	al	2560	0.00	1356
+f	al	5120	0.00	1316
+f	al	10240	0.00	1464
+f	al	20480	0.00	1584
+f	al	40960	0.00	1948
+f	al	81920	0.01	2540
+f	al	163840	0.03	3652
+f	al	327680	0.07	6308
+f	al	655360	0.14	11456
+r	de	10	0.00	1312
+r	de	20	0.00	1152
+r	de	40	0.00	1200
+r	de	80	0.00	1292
+r	de	160	0.00	1308
+r	de	320	0.00	1216
+r	de	640	0.00	1240
+r	de	1280	0.00	1400
+r	de	2560	0.01	1376
+r	de	5120	0.04	1644
+r	de	10240	0.18	2000
+r	de	20480	0.74	2756
+r	de	40960	2.95	4188
+r	de	81920	NA	NA
+r	de	163840	NA	NA
+r	de	327680	NA	NA
+r	de	655360	NA	NA
+r	cr	10	0.00	1204
+r	cr	20	0.00	1256
+r	cr	40	0.00	1308
+r	cr	80	0.00	1388
+r	cr	160	0.00	1316
+r	cr	320	0.00	1332
+r	cr	640	0.00	1348
+r	cr	1280	0.00	1348
+r	cr	2560	0.01	1444
+r	cr	5120	0.06	1672
+r	cr	10240	0.26	1916
+r	cr	20480	1.03	2724
+r	cr	40960	4.12	4092
+r	cr	81920	NA	NA
+r	cr	163840	NA	NA
+r	cr	327680	NA	NA
+r	cr	655360	NA	NA
+r	co	10	0.00	1208
+r	co	20	0.00	1268
+r	co	40	0.00	1320
+r	co	80	0.00	1252
+r	co	160	0.00	1244
+r	co	320	0.00	1328
+r	co	640	0.00	1328
+r	co	1280	0.00	1336
+r	co	2560	0.01	1484
+r	co	5120	0.06	1644
+r	co	10240	0.26	1952
+r	co	20480	1.03	2744
+r	co	40960	4.13	4188
+r	co	81920	NA	NA
+r	co	163840	NA	NA
+r	co	327680	NA	NA
+r	co	655360	NA	NA
+r	al	10	0.00	1316
+r	al	20	0.00	1388
+r	al	40	0.00	1252
+r	al	80	0.00	1228
+r	al	160	0.00	1268
+r	al	320	0.00	1300
+r	al	640	0.00	1332
+r	al	1280	0.00	1316
+r	al	2560	0.00	1284
+r	al	5120	0.00	1348
+r	al	10240	0.00	1352
+r	al	20480	0.00	1464
+r	al	40960	0.00	1640
+r	al	81920	0.01	1844
+r	al	163840	0.02	2576
+r	al	327680	0.05	3864
+r	al	655360	0.11	6416
+i	de	10	0.00	1320
+i	de	20	0.00	1320
+i	de	40	0.00	1300
+i	de	80	0.00	1328
+i	de	160	0.00	1264
+i	de	320	0.00	1316
+i	de	640	0.00	1320
+i	de	1280	0.00	1316
+i	de	2560	0.00	1344
+i	de	5120	0.03	1348
+i	de	10240	0.12	1364
+i	de	20480	0.49	1480
+i	de	40960	1.96	1712
+i	de	81920	7.89	1972
+i	de	163840	NA	NA
+i	de	327680	NA	NA
+i	de	655360	NA	NA
+i	cr	10	0.00	1268
+i	cr	20	0.00	1268
+i	cr	40	0.00	1272
+i	cr	80	0.00	1320
+i	cr	160	0.00	1292
+i	cr	320	0.00	1300
+i	cr	640	0.00	1312
+i	cr	1280	0.00	1220
+i	cr	2560	0.00	1304
+i	cr	5120	0.00	1308
+i	cr	10240	0.00	1400
+i	cr	20480	0.00	1472
+i	cr	40960	0.00	1616
+i	cr	81920	0.00	1936
+i	cr	163840	0.00	2596
+i	cr	327680	0.00	3868
+i	cr	655360	0.00	6388
+i	co	10	0.00	1204
+i	co	20	0.00	1308
+i	co	40	0.00	1264
+i	co	80	0.00	1296
+i	co	160	0.00	1200
+i	co	320	0.00	1292
+i	co	640	0.00	1328
+i	co	1280	0.00	1272
+i	co	2560	0.00	1316
+i	co	5120	0.00	1356
+i	co	10240	0.00	1372
+i	co	20480	0.00	1432
+i	co	40960	0.00	1640
+i	co	81920	0.00	1880
+i	co	163840	0.00	2552
+i	co	327680	0.00	3876
+i	co	655360	0.00	6416
+i	al	10	0.00	1328
+i	al	20	0.00	1284
+i	al	40	0.00	1308
+i	al	80	0.00	1320
+i	al	160	0.00	1304
+i	al	320	0.00	1284
+i	al	640	0.00	1272
+i	al	1280	0.00	1324
+i	al	2560	0.00	1344
+i	al	5120	0.01	1308
+i	al	10240	0.06	1396
+i	al	20480	0.25	1460
+i	al	40960	0.98	1712
+i	al	81920	3.93	1960
+i	al	163840	NA	NA
+i	al	327680	NA	NA
+i	al	655360	NA	NA

tp2/triFusion.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+void fusion(long* A,size_t p,size_t q,size_t r){
+	size_t n1 = q-p;
+	size_t n2 = r-q;
+	long* Ag = malloc(n1*sizeof(long));
+	long* Ad = malloc(n2*sizeof(long));
+	copierTableau(Ag,A+p,n1);
+	copierTableau(Ad,A+q,n2);
+	size_t indG = 0;
+	size_t indD = 0;
+	size_t i = p;
+	while(i < r){
+		if(indG == n1){
+			A[i] = Ad[indD];
+			indD++;
+		}else if(indD == n2){
+			A[i] = Ag[indG];
+			indG++;
+		}else if(Ag[indG] < Ad[indD]){
+			A[i] = Ag[indG];
+			indG++;
+		}else{
+			A[i] = Ad[indD];
+			indD++;
+		}
+		i++;
+	}
+	free(Ad);
+	free(Ag);
+}
+
+void sousTriFusion(long* A,size_t p,size_t r){
+	if(p+1 < r){
+		size_t q = (p+r)/2;
+		sousTriFusion(A,p,q);
+		sousTriFusion(A,q,r);
+		fusion(A,p,q,r);
+	}
+}
+
+void triFusion(long* A,size_t n){
+	sousTriFusion(A,0,n);
+}
+
+/*int main(int argc,char** argv){
+	long* A = malloc((argc-1)*sizeof(long));
+	for(size_t i = 0;i < argc-1;i++){
+		A[i] = atol(argv[i+1]);
+	}
+	printf("Tableau d'entrée: ");
+	printTab(A,argc-1);
+	triFusion(A,argc-1);
+	printf("Tableau de sortie: ");
+	printTab(A,argc-1);
+	free(A);
+}
+*/

tp2/triFusion.h

+#include "utils.h"
+
+void triFusion(long* A,size_t n);

tp2/triInsertion.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+void triInsertion(long* A, size_t n){
+  for(size_t i = 1; i < n; i ++){
+    long cle = A[i];
+    size_t j = i - 1;
+    while(j + 1 > j && A[j] > cle){ // ici on veut regarder tant que j >= 0
+      A[j + 1] = A[j];
+      j = j - 1;
+    }
+    A[j + 1] = cle;
+  }
+}
+
+/*int main(int argc, char* argv[]){
+  long* A = malloc((argc-1)*sizeof(long));
+	for(size_t i = 0;i < argc-1;i++){
+		A[i] = atol(argv[i+1]);
+	}
+	printf("Tableau d'entrée: ");
+	printTab(A,argc-1);
+	triInsertion(A,argc-1);
+	printf("Tableau de sortie: ");
+	printTab(A,argc-1);
+	free(A);
+}
+*/

tp2/triInsertion.h

+#include "utils.h"
+
+void triInsertion(long* A, size_t n);

tp2/triRapide.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+long choisirPivotDernier(long* A,size_t p,size_t r){
+	return A[r-1];
+}
+
+long choisirPivotAlea(long* A,size_t p,size_t r){
+	return A[rand()%(r-p)+p];
+}
+
+long choisirPivotMedian(long* A,size_t p,size_t r){
+	long a = choisirPivotAlea(A,p,r);
+	long b = choisirPivotAlea(A,p,r);
+	long c = choisirPivotAlea(A,p,r);
+	long res;
+	if((b <= a && a <= c) || (c >= a && a >= b)){
+		res = a;
+	}else if((a <= b && b <= c) || (c >= b && b >= a)){
+		res = b;
+	}else if((b <= c && c <= a) || (a >= c && c >= b)){
+		res = c;
+	}else{
+		printf("non\n");
+	}
+	return res;
+}
+
+size_t partition(long* A,size_t p,size_t r){
+	long pivot;
+	#ifdef PIVOT_ALEA
+		pivot = choisirPivotAlea(A,p,r);
+	#elif defined PIVOT_MEDIAN
+		pivot = choisirPivotMedian(A,p,r);
+	#else
+		pivot = choisirPivotDernier(A,p,r);//A[r-1];
+	#endif
+	size_t i = p;
+	for(size_t j = p;j < r-1;j++){
+		if(A[j] <= pivot){
+			permuter(A+i,A+j);
+			i++;
+		}
+	}
+	permuter(A+i,A+r-1);
+	return i;
+}
+
+void sousTriRapide(long* A,size_t p,size_t r){
+	if(p+1 < r){
+		size_t q = partition(A,p,r);
+		sousTriRapide(A,p,q);
+		sousTriRapide(A,q+1,r);
+	}
+}
+
+void triRapide(long* A,size_t n){
+	sousTriRapide(A,0,n);
+}
+
+/*int main(int argc,char** argv){
+	long* A = malloc((argc-1)*sizeof(long));
+	for(size_t i = 0;i < argc-1;i++){
+		A[i] = atol(argv[i+1]);
+	}
+	printf("Tableau d'entrée: ");
+	printTab(A,argc-1);
+	triRapide(A,argc-1);
+	printf("Tableau de sortie: ");
+	printTab(A,argc-1);
+	free(A);
+}
+*/

tp2/triRapide.h

+#include "utils.h"
+
+void triRapide(long* A,size_t n);

tp2/utils.c

+#include "utils.h"
+
+void copierTableau(long* dest,long* src,size_t n){
+	for(size_t i = 0;i < n;i++){
+		dest[i] = src[i];
+	}
+}
+
+void printTab(long* A,size_t n){
+	printf("{");
+	for(size_t i = 0;i < n;i++){
+		if(i != 0){
+
+			printf(",");
+		}
+		printf("%ld",A[i]);
+	}
+	printf("}\n");
+}
+
+void permuter(long* a,long* b){
+	long tmp = *a;
+	*a = *b;
+	*b = tmp;
+}
+
+void initCompte(struct compte* c){
+	c->comp = 0;
+	c->ecrit = 0;
+}
+
+char comparer(long a,char* op,long b,struct compte* c){
+	c->comp++;
+	if(!strcmp(op,"==")){
+		return (a == b);
+	}else if(!strcmp(op,"<")){
+		return (a < b);
+	}else if(!strcmp(op,">")){
+		return (a > b);
+	}else if(!strcmp(op,"<=")){
+		return (a <= b);
+	}else if(!strcmp(op,">=")){
+		return (a >= b);
+	}
+	return 0;
+}
+
+void ecrire(long* a,long b,struct compte* c){
+	c->ecrit++;
+	*a = b;
+}
+
+void tabDec(long* tab,size_t longueur){
+	for(size_t i = 0;i < longueur;i++){
+		tab[i] = longueur-i;
+	}
+}
+
+void tabCroi(long* tab,size_t longueur){
+	for(size_t i = 0;i < longueur;i++){
+		tab[i] = i;
+	}
+}
+
+void tabConst(long* tab,size_t longueur){
+	for(size_t i  = 0;i < longueur;i++){
+		tab[i] = 0;
+	}
+}
+
+void tabAlea(long* tab,size_t longueur){
+	for(size_t i = 0;i < longueur;i++){
+		tab[i] = rand();
+	}
+}