TP1/tridec.h

+#ifndef TRIS_H
+#define TRIS_H
+#include <stdint.h>
+#include <stdlib.h>
+
+void triInsertionDec(long* A, size_t n);
+
+void triFusionDec(long* A, size_t size);
+void sousTriFusionDec(long* A, size_t first, size_t size);
+void fusionDec(long* A, size_t first, size_t middle, size_t size);
+
+void triRapideDec(long* A, size_t n);
+void sousTriRapideDec(long* A, size_t first, size_t size);
+size_t partitionDec(long* A, size_t first, size_t size);
+void permuterDec(long* A,size_t i,size_t j);
+
+#endif //TRIS_H
\ No newline at end of file

TP1/tris.c

+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "tris.h"
+
+void triInsertion(long* A, size_t n) {
+    for(size_t i = 1; i <= n-1; i++){
+        long cle = A[i];
+        size_t j = i - 1;
+        while(j+1 >= j && A[j] > cle){
+            A[j+1] = A[j];
+            j = j-1;
+        }
+        A[j+1] = cle;
+    }
+}
+
+void triFusion(long* A, size_t size) {
+  sousTriFusion(A, 0, size);
+}
+
+void sousTriFusion(long* A, size_t first, size_t size) {
+    if(first+1 <size){ // p < r - 1
+        size_t middle = floor((first+size)/2);
+        sousTriFusion(A, first, middle);
+        sousTriFusion(A, middle, size);
+        fusion(A, first, middle, size);
+    }
+}
+
+void copySousTable(long* mainT, long* underT, size_t id, size_t size) {
+  for(size_t i = id; i < id+size; ++i) {
+    underT[i-id] = mainT[i];
+  }
+}
+
+void fusion(long* A, size_t first, size_t middle, size_t size) {
+    size_t n1 = middle - first; // Nb elem dans A[p , q]  q exclu
+    size_t n2 = size - middle;  // Nb elem dans A[q , r]  r exclu
+
+    size_t indg = 0;
+    size_t indd = 0;
+
+    long* ag = malloc(sizeof(long) * n1);
+    long* ad = malloc(sizeof(long) * n2);
+
+    copySousTable(A, ag, first, n1);
+    copySousTable(A, ad, middle, n2);
+
+    int i = first;
+
+    while(i < size) {
+      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(ag);
+    free(ad);
+}
+
+void triRapide(long* A, size_t n) {
+    sousTriRapide(A,0,n);
+}
+
+void sousTriRapide(long* A, size_t first, size_t size){
+    if(first+1 < size){
+        size_t middle = partition(A,first,size);
+        sousTriRapide(A,first,middle);
+        sousTriRapide(A,middle+1,size);
+    }
+}
+
+size_t partition(long* A, size_t first, size_t size) {
+    long pivot = A[size-1];
+    size_t i = first;
+    for(int j = first; j+2 <= size; j++){
+        if(A[j] <= pivot){
+            permuter(A,i,j);
+            i++;
+        }
+    }
+    permuter(A,i,size-1);
+    return i;
+}
+
+void permuter(long* A,size_t i,size_t j) {
+    long inter = A[i];
+    A[i] = A[j];
+    A[j] = inter;
+}

TP1/tris.h

+#ifndef TRIS_H
+#define TRIS_H
+#include <stdint.h>
+#include <stdlib.h>
+
+void triInsertion(long* A, size_t n);
+
+void triFusion(long* A, size_t size);
+void sousTriFusion(long* A, size_t first, size_t size);
+void fusion(long* A, size_t first, size_t middle, size_t size);
+
+void triRapide(long* A, size_t n);
+void sousTriRapide(long* A, size_t first, size_t size);
+size_t partition(long* A, size_t first, size_t size);
+void permuter(long* A,size_t i,size_t j);
+
+#endif //TRIS_H

TP1/utils.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "utils.h"
+
+void affichertab(long* T, int s){
+    printf("[ ");
+    for(int i = 0; i < s-1; i++){
+        printf("%d , ",T[i]);
+    }
+    printf("%d ]\n",T[s-1]);
+}
+
+long* listeAlea(size_t longeur, size_t N){
+    long liste[longeur];
+    for(size_t i = 0; i < longeur; i++){
+        liste[i] = rand() % N; 
+    }
+    return liste;  
+} 
\ No newline at end of file

TP1/utils.h

+#include <stdio.h>
+#include <stdlib.h>
+
+void affichertab(long* T, int s);
+long* listeAlea(size_t longeur, size_t N);
\ No newline at end of file

TP2/.gitignore

+*.o
+main

TP2/Makefile

+all: main
+
+main : tri_fusion.o tri_insertion.o tri_rapide.o utils.o main.c
+	gcc -o main -Wall utils.o tri_fusion.o tri_insertion.o tri_rapide.o -g main.c
+
+tri_fusion.o : tri_fusion.c tri_fusion.h
+	gcc -c -Wall -g tri_fusion.c
+
+tri_insertion.o : tri_insertion.c tri_insertion.h
+	gcc -c -Wall -g tri_insertion.c
+
+tri_rapide.o : tri_rapide.c tri_rapide.h
+	gcc -c -Wall -g tri_rapide.c
+
+utils.o : utils.c utils.h
+	gcc -c -g utils.c
+clean :
+	rm *.o

TP2/main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "tri_insertion.h"
+#include "tri_rapide.h"
+#include "tri_fusion.h"
+
+#include "utils.h"
+
+int main(int argc, char *argv[]) {
+  if(argc != 6) {
+    printf("Usage: %s [typeAlgo] [taille] [typeTableau] [isAfficher] [versionRap]\n", argv[0]);
+    exit(1);
+  }
+
+  char typeAlgo = argv[1][0];
+  long taille = (long) atoi(argv[2]);
+  long MAX = 50;
+  long *tab = malloc(sizeof(long) * taille);
+  char typeTable = argv[3][0];
+  size_t afficher = (size_t) atoi(argv[4]);
+  int versionRap = (size_t) atoi(argv[5]);
+
+  genTab(tab, taille, typeTable, MAX);
+
+  switch(typeAlgo) {
+    case 'i':
+      triInsertion(tab,taille);
+
+      if(afficher) {
+        printf("Tri Insertion: \n");
+        affichertab(tab,taille);
+      }
+
+      break;
+
+    case 'r':
+      triRapide(tab, taille, versionRap);
+
+      if(afficher) {
+        printf("Tri Rapide: \n");
+        affichertab(tab,taille);
+      }
+
+      break;
+
+    case 'f':
+      triFusion(tab, taille);
+
+      if(afficher) {
+        printf("Tri Fusion: \n");
+        affichertab(tab,taille);
+      }
+      break;
+  }
+
+  free(tab);
+
+  return 0;
+}

TP2/testGeneral.R

+library(ggplot2)
+perf <- read.table("testGeneral.dat", header = TRUE)
+ggplot(perf, aes(x=taille, y=temps, group=typeTableau, colour=as.character(algo))) + facet_grid(algo ~ typeTableau) +
+geom_point() + geom_smooth() +
+ ggtitle("Test General des Algos")
+
+ggsave("testGeneral.png")

TP2/testGeneral.dat

+iTest	taille	temps	mem	algo	typeTableau
+1	30000	0.04	1396	r	a
+1	40000	0.06	1400	r	a
+1	50000	0.08	1388	r	a
+1	30000	1.38	3200	r	c
+1	40000	2.45	3756	r	c
+1	50000	3.87	4568	r	c
+1	30000	1.38	3192	r	r
+1	40000	2.43	3748	r	r
+1	50000	3.81	4568	r	r
+1	30000	1.35	3312	r	i
+1	40000	2.40	3812	r	i
+1	50000	3.74	4472	r	i
+2	30000	0.03	1352	r	a
+2	40000	0.05	1380	r	a
+2	50000	0.08	1348	r	a
+2	30000	1.37	3168	r	c
+2	40000	2.42	3732	r	c
+2	50000	3.79	4564	r	c
+2	30000	1.39	3248	r	r
+2	40000	2.42	3884	r	r
+2	50000	3.79	4560	r	r
+2	30000	1.35	3236	r	i
+2	40000	2.41	3732	r	i
+2	50000	3.74	4564	r	i
+3	30000	0.04	1384	r	a
+3	40000	0.05	1352	r	a
+3	50000	0.08	1400	r	a
+3	30000	1.43	3228	r	c
+3	40000	2.43	3696	r	c
+3	50000	3.79	4568	r	c
+3	30000	1.42	3168	r	r
+3	40000	2.42	3748	r	r
+3	50000	3.87	4504	r	r
+3	30000	1.41	3192	r	i
+3	40000	2.47	3820	r	i
+3	50000	3.79	4484	r	i
+4	30000	0.04	1344	r	a
+4	40000	0.06	1396	r	a
+4	50000	0.09	1404	r	a
+4	30000	1.37	3184	r	c
+4	40000	2.49	3884	r	c
+4	50000	3.85	4632	r	c
+4	30000	1.36	3136	r	r
+4	40000	2.41	3764	r	r
+4	50000	3.77	4572	r	r
+4	30000	1.34	3204	r	i
+4	40000	2.39	3816	r	i
+4	50000	3.81	4776	r	i
+5	30000	0.04	1400	r	a
+5	40000	0.06	1352	r	a
+5	50000	0.10	1356	r	a
+5	30000	1.36	3192	r	c
+5	40000	2.41	3764	r	c
+5	50000	3.77	4480	r	c
+5	30000	1.38	3236	r	r
+5	40000	2.42	3764	r	r
+5	50000	3.78	4568	r	r
+5	30000	1.34	3156	r	i
+5	40000	2.40	3812	r	i
+5	50000	3.75	4456	r	i

TP2/testGeneral.sh

+#!/bin/bash
+
+affichage=0
+versionRap=0
+#taille=100
+
+echo -e "iTest\ttaille\ttemps\tmem\talgo\ttypeTableau"
+
+for iTest in `seq 1 5`
+do
+  #taille=$(( `od -An -N4 -tu < /dev/urandom` % 1000000))
+  #taille=1000000
+
+  for algo in 'r' 'i' 'f'
+  do
+
+    for typeTableau in 'a' 'c' 'r' 'i'
+      do
+        for taille in 30000 40000 50000 60000 70000 80000 90000
+          do
+            res=`( /usr/bin/time -f "%U\t%M" ./main $algo $taille $typeTableau $affichage $versionRap > /dev/null ) 2>&1`
+            echo -e "$iTest\t$taille\t$res\t$algo\t$typeTableau"
+          done
+    done
+  done
+done

TP2/tri_fusion.c

+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "tri_fusion.h"
+
+void triFusion(long* A, size_t size) {
+  sousTriFusion(A, 0, size);
+}
+
+void sousTriFusion(long* A, size_t first, size_t size) {
+    if(first+1 <size){ // p < r - 1
+        size_t middle = floor((first+size)/2);
+        sousTriFusion(A, first, middle);
+        sousTriFusion(A, middle, size);
+        fusion(A, first, middle, size);
+    }
+}
+
+void copySousTable(long* mainT, long* underT, size_t id, size_t size) {
+  for(size_t i = id; i < id+size; ++i) {
+    underT[i-id] = mainT[i];
+  }
+}
+
+void fusion(long* A, size_t first, size_t middle, size_t size) {
+    size_t n1 = middle - first; // Nb elem dans A[p , q]  q exclu
+    size_t n2 = size - middle;  // Nb elem dans A[q , r]  r exclu
+
+    size_t indg = 0;
+    size_t indd = 0;
+
+    long* ag = malloc(sizeof(long) * n1);
+    long* ad = malloc(sizeof(long) * n2);
+
+    copySousTable(A, ag, first, n1);
+    copySousTable(A, ad, middle, n2);
+
+    int i = first;
+
+    while(i < size) {
+      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(ag);
+    free(ad);
+}
\ No newline at end of file

TP2/tri_fusion.h

+#ifndef TRIS_F
+#define TRIS_F
+#include <stdint.h>
+#include <stdlib.h>
+
+void triFusion(long* A, size_t size);
+void sousTriFusion(long* A, size_t first, size_t size);
+void fusion(long* A, size_t first, size_t middle, size_t size);
+#endif //TRIS_H
\ No newline at end of file

TP2/tri_insertion.c

+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "tri_insertion.h"
+
+void triInsertion(long* A, size_t n) {
+    for(size_t i = 1; i <= n-1; i++){
+        long cle = A[i];
+        size_t j = i - 1;
+        while(j+1 >= j && A[j] > cle){
+            A[j+1] = A[j];
+            j = j-1;
+        }
+        A[j+1] = cle;
+    }
+}
\ No newline at end of file

TP2/tri_insertion.h

+#ifndef TRIS_I
+#define TRIS_I
+#include <stdint.h>
+#include <stdlib.h>
+
+void triInsertion(long* A, size_t n);
+#endif //TRIS_H
\ No newline at end of file

TP2/tri_rapide.c

+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "tri_rapide.h"
+
+
+void triRapide(long* A, size_t n, int version) {
+    sousTriRapide(A,0,n, version);
+}
+
+void sousTriRapide(long* A, size_t first, size_t size, int version){
+    if(first+1 < size){
+        size_t middle = partition(A,first,size, version);
+        sousTriRapide(A,first,middle, version);
+        sousTriRapide(A,middle+1,size, version);
+    }
+}
+
+size_t partition(long* A, size_t first, size_t size, int version) {
+    //long middle = (size-1) / 2;
+    //long pivot = A[middle];
+
+    long pivot = A[size-1];
+
+    size_t i = first;
+    for(int j = first; j+2 <= size; j++){
+        if(A[j] <= pivot) {
+            // Version 1: optimisation sur les tableaux ranges
+            if(version == 1) {
+              // Si i = j, pas besoin de permuter
+              if(i != j ) {
+                permuter(A,i,j);
+              }
+            }
+            // Version 0: celle de base
+            else {
+              permuter(A,i,j);
+            }
+
+            i++;
+        }
+    }
+    permuter(A,i,size-1);
+    return i;
+}
+
+void permuter(long* A,size_t i,size_t j) {
+    long inter = A[i];
+    A[i] = A[j];
+    A[j] = inter;
+}