.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
+
+main: main.c tris.o utils.o
+	gcc -Wall -o $@ $^
+
+%.o: %.c
+	gcc -Wall -c $^
+
+%: %.c utils.o
+	gcc -Wall -o $@ $^

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);
+}

triFusionCompte.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+void fusion(long* A,size_t p,size_t q,size_t r,struct compte* c){
+	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);
+	c->ecrit += n1+n2;
+	size_t indG = 0;
+	size_t indD = 0;
+	size_t i = p;
+	while(comparer(i,"<",r,c)/*i < r*/){
+		if(comparer(indG,"==",n1,c)/*indG == n1*/){
+			//A[i] = Ad[indD];
+			ecrire(A+i,Ad[indD],c);
+			indD++;
+		}else if(comparer(indD,"==",n2,c)/*indD == n2*/){
+			//A[i] = Ag[indG];
+			ecrire(A+i,Ag[indG],c);
+			indG++;
+		}else if(comparer(Ag[indG],"<",Ad[indD],c)/*Ag[indG] < Ad[indD]*/){
+			//A[i] = Ag[indG];
+			ecrire(A+i,Ag[indG],c);
+			indG++;
+		}else{
+			//A[i] = Ad[indD];
+			ecrire(A+i,Ad[indD],c);
+			indD++;
+		}
+		i++;
+	}
+	free(Ad);
+	free(Ag);
+}
+
+void sousTriFusion(long* A,size_t p,size_t r,struct compte* c){
+	if(/*comparer(p+1,"<",r,c)*/p+1 < r){
+		size_t q = (p+r)/2;
+		sousTriFusion(A,p,q,c);
+		sousTriFusion(A,q,r,c);
+		fusion(A,p,q,r,c);
+	}
+}
+
+void triFusion(long* A,size_t n,struct compte* c){
+	sousTriFusion(A,0,n,c);
+}
+
+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]);
+	}
+	struct compte c;
+	initCompte(&c);
+	printf("Tableau d'entrée: ");
+	printTab(A,argc-1);
+	triFusion(A,argc-1,&c);
+	printf("Tableau de sortie: ");
+	printTab(A,argc-1);
+	printf("Comparaisons: %lu\nEcritures: %lu\n",c.comp,c.ecrit);
+	free(A);
+}

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);
+}

triRapide.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+size_t partition(long* A,size_t p,size_t r){
+	long pivot = A[r-1];
+	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);
+}

triRapideCompte.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+size_t partition(long* A,size_t p,size_t r,struct compte* c){
+	long pivot = A[r-1];
+	size_t i = p;
+	for(size_t j = p;j < r-1;j++){
+		if(comparer(A[j],"<=",pivot,c)/*A[j] <= pivot*/){
+			permuter(A+i,A+j);
+			c->ecrit += 3;
+			i++;
+		}
+	}
+	permuter(A+i,A+r-1);
+	c->ecrit += 3;
+	return i;
+}
+
+void sousTriRapide(long* A,size_t p,size_t r,struct compte* c){
+	if(/*comparer(p+1,"<",r,c)*/p+1 < r){
+		size_t q = partition(A,p,r,c);
+		sousTriRapide(A,p,q,c);
+		sousTriRapide(A,q+1,r,c);
+	}
+}
+
+void triRapide(long* A,size_t n,struct compte* c){
+	sousTriRapide(A,0,n,c);
+}
+
+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]);
+	}
+	struct compte c;
+	initCompte(&c);
+	printf("Tableau d'entrée: ");
+	printTab(A,argc-1);
+	triRapide(A,argc-1,&c);
+	printf("Tableau de sortie: ");
+	printTab(A,argc-1);
+	printf("Comparaisons: %lu\nEcritures: %lu\n",c.comp,c.ecrit);
+	free(A);
+}

tris.c

+#include "tris.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);
+}
+
+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;
+  }
+}
+
+size_t partition(long* A,size_t p,size_t r){
+	long pivot = A[r-1];
+	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);
+}

tris.h

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+void fusion(long* A,size_t p,size_t q,size_t r);
+
+void sousTriFusion(long* A,size_t p,size_t r);
+
+void triFusion(long* A,size_t n);
+
+void triInsertion(long* A, size_t n);
+
+size_t partition(long* A,size_t p,size_t r);
+
+void sousTriRapide(long* A,size_t p,size_t r);
+
+void triRapide(long* A,size_t n);

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;
+}

utils.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+
+struct compte{
+	size_t comp;
+	size_t ecrit;
+};
+
+void copierTableau(long* dest,long* src,size_t n);
+
+void printTab(long* A,size_t n);
+
+void permuter(long* a,long* b);
+
+void initCompte(struct compte* c);
+
+char comparer(long a,char* op,long b,struct compte* c);
+
+void ecrire(long* a,long b,struct compte* c);