TP1 rendu

TP1/Makefile

@@ -7,6 +7,6 @@ tris.o : tris.c tris.h
 	gcc -c -Wall -g tris.c
 
 utils.o : utils.c utils.h
-	gcc -o utils.o -c -g utils.c
+	gcc -c -Wall -g utils.c
 clean :
 	rm *.o

TP1/main.c

@@ -5,24 +5,34 @@
 
 
 int main() {
+  long taille = (long) 100;
+
   printf("Tri Insertion: \n");
-  long* triIns = malloc(sizeof(long) * 100);
-  listeAlea(100,300);
+  long* triIns = malloc(sizeof(long) * taille);
+  listeAlea(triIns,100,300);
   affichertab(triIns,100);
   triInsertion(triIns,100);
   affichertab(triIns,100);
 
+  free(triIns);
+
   printf("Tri Rapide: \n");
-  long* triRap = listeAlea(100,300);
+  long* triRap = malloc(sizeof(long) * taille);
+  listeAlea(triRap,100,300);
   affichertab(triRap,100);
   triRapide(triRap, 100);
   affichertab(triRap,100);
 
+  free(triRap);
+
   printf("Tri Fusion: \n");
-  long* triFus = listeAlea(100,300);
+  long* triFus = malloc(sizeof(long) * taille);
+  listeAlea(triFus,100,300);
   affichertab(triFus,100);
   triFusion(triFus, 100);
   affichertab(triFus,100);
 
+  free(triFus);
+
   return 0;
 }

TP1/utils.c

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

TP1/utils.h

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

renduTP1/Makefile

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

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

renduTP1/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