added sorting codes

source_codes/sorting/heapsort.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "heapsort.h"
+
+static void swap(int* a,int* b) {
+   int tmp = *a;
+   *a = *b;
+   *b = tmp;
+}
+
+static void print(int* tab,int size,char* str) {
+   for (int i=0;i<size;i++) {
+      printf("%d ",tab[i]);
+   }
+   printf("%s",str);
+}
+
+void heapsort(int* tab,int size) {
+   entassement(tab,size);
+   swap(tab,tab+size-1);
+   for (int s=size-1;s>1;s--) {
+      promotion(tab,s,0);
+      swap(tab,tab+s-1);
+   }
+}
+void entassement(int* tab,int size) {
+   for (int i=size/2-1;i>=0;i--) {
+      promotion(tab,size,i);
+   }
+}
+
+void promotion(int* tab,int size,int i) {
+   int ind_max = max3(tab,size,i);
+   if (ind_max != i) {
+      promotion(tab,size,ind_max);
+   } 
+}
+
+int max3(int* tab,int size,int i) {
+   int ind_max = i;
+   int left = fils_g(i), right = fils_d(i);
+   if (left  < size && tab[ind_max] < tab[left]) {
+      ind_max = left;
+   }
+   if (right < size && tab[ind_max] < tab[right]) {
+      ind_max = right;
+   }
+   if (i != ind_max) {
+      swap(tab+i,tab+ind_max);
+   }
+   return ind_max; 
+}
+
+int fils_g(int i) { 
+   return 2*i+1; 
+}
+
+int fils_d(int i) {
+   return 2*i+2; 
+}
+
+

source_codes/sorting/heapsort.h

+#ifndef HEAPSORT_H
+#define HEAPSORT_H
+
+int fils_g(int i);
+int fils_d(int i);
+int max3(int* tab,int size,int i);
+void promotion(int* tab,int size,int i);
+void entassement(int* tab,int size);
+void heapsort(int* tab,int size);
+
+#endif

source_codes/sorting/heapsort_main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "heapsort.h"
+
+void rand_init(int* tab,int size,int inf,int delta);
+void print(int* tab,int size,char* str);
+
+int main(int argc, char** argv) {
+   srand(time(0));
+   int size = 10, inf = 0, delta = 20;
+   switch(argc) {
+      case 4: delta = atoi(argv[3]);
+      case 3: inf = atoi(argv[2]);     
+      case 2: size = atoi(argv[1]);
+   }
+   int* tab = (int*)malloc(size*sizeof(int));
+   rand_init(tab,size,inf,delta);
+   print(tab,size,"\n=========\n");
+   heapsort(tab,size);
+   print(tab,size,"\n=========\n");
+   return 0;
+}
+
+void print(int* tab,int size,char* str) {
+   for (int i=0;i<size;i++) {
+      printf("%d ",tab[i]);
+   }
+   printf("%s",str);
+}
+
+void rand_init(int* tab,int size,int inf,int delta) {
+   for (int i=0;i<size;i++) {
+      tab[i] = inf+rand()%delta;
+   }
+}
+
+

source_codes/sorting/heapsort_part.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "heapsort.h"
+
+static void swap(int* a,int* b) {
+   // à compléter
+}
+
+void heapsort(int* tab,int size) {
+   entassement(tab,size);
+   swap(tab,tab+size-1);
+   for (int s=size;s>1;s--) {
+      promotion(tab,s,0);
+      swap(tab,tab+s-1);
+   }
+}
+void entassement(int* tab,int size) {
+   // à compléter
+}
+
+void promotion(int* tab,int size,int i) {
+   int ind_max = max3(tab,size,i);
+   if (ind_max != i) {
+      promotion(tab,size,i);
+   } 
+}
+
+int max3(int* tab,int size,int i) {
+   int ind_max = i;
+   int left = fils_g(i), right = fils_d(i);
+   // à compléter
+   return ind_max; 
+}
+
+int fils_g(int i) { 
+   // à compléter
+   return 0;
+}
+
+int fils_d(int i) {
+   // à compléter
+   return 0; 
+}
+
+

source_codes/sorting/quicksort.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+
+void print(int size,int tab[size]) {
+   for (int i=0;i<size;i++) printf("%d ",tab[i]);
+}
+
+void random_tab(int size,int tab[size],int inf,int sup) {
+   assert(sup > inf);
+   for (int i=0;i<size;i++) tab[i] = inf+rand()%(sup-inf);
+}
+
+void swap(int* p_a,int* p_b) { 
+   int tmp = *p_a;
+   *p_a = *p_b;
+   *p_b = tmp;
+}
+
+int partition(int size,int array[size],int first,int last) {
+   int pivot = array[last];
+   int i = first-1,j = last;
+   while (true) {
+      do {
+         i++;
+      } while (array[i] < pivot && i<j);
+      do {
+         j--;
+      } while(array[j] > pivot && i<j);
+      if (i >= j) break;
+      swap(&array[i],&array[j]);
+   }
+   swap(&array[i],&array[last]);
+   return i;
+}
+
+void quicksort(int size,int array[size],int first,int last) {
+   if (first < last) {
+      int midpoint = partition(size,array,first,last);
+      if (first < midpoint-1) quicksort(size,array,first,midpoint-1);
+      if (midpoint+1 < last) quicksort(size,array,midpoint+1,last);
+   }
+}
+
+void test_ordre(int size,int array[size]) {
+   for (int i=0;i<size-1;i++) 
+      if (array[i] > array[i+1]) {
+         printf("erreur");
+         return;
+      }
+   printf("ok");
+}
+
+int main(int argc,char** argv) {
+   int size = atoi(argv[1]);
+   int seed = atoi(argv[2]);
+   srand(seed);
+   int* res = (int*)malloc(size*sizeof(int));
+   for (int k=0;k<20;k++) {
+      random_tab(size,res,0,100);
+      print(size,res);
+      printf("\n");
+      quicksort(size,res,0,size-1);
+      print(size,res);
+      test_ordre(size,res);
+      printf("\n================\n");
+   }
+}
+

source_codes/sorting/quicksort_part.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+
+void print(int size,int tab[size]) {
+   for (int i=0;i<size;i++) {
+      printf("%d ",tab[i]);
+   }
+}
+
+void random_tab(int size,int tab[size],int inf,int sup) {
+   assert(sup > inf);
+   for (int i=0;i<size;i++) {
+      tab[i] = inf+rand()%(sup-inf);
+   }
+}
+
+void swap(int* p_a,int* p_b) { 
+   int tmp = *p_a;
+   *p_a = *p_b;
+   *p_b = tmp;
+}
+
+// Partition du tableau <array> autour d'une valeur pivot:
+// compléter le code
+int partition(int size,int array[size],int first,int last) {
+   int pivot = array[last];
+   int i = first-1,j = last;
+   while (true) {
+      // à compléter pour <i>: do {...} while (...);
+      // à compléter pour <j>: do {...} while (...);
+      if (i >= j) {
+         break;
+      }
+      // à compléter: échanger cases <i> et <j> du tableau <array>
+   }
+   // à compléter: échanger cases <i> et <last> du tableau <array>
+   return i;
+}
+
+// Tri rapide récursif
+void quicksort(int size,int array[size],int first,int last) {
+   if (first < last) {
+      int midpoint = partition(size,array,first,last);
+      if (first < midpoint-1) {
+         quicksort(size,array,first,midpoint-1);
+      }
+      if (midpoint+1 < last) {
+         quicksort(size,array,midpoint+1,last);
+      }
+   }
+}
+
+// Test si le tableau <array> est ordonné croissant
+void test_ordre(int size,int array[size]) {
+   for (int i=0;i<size-1;i++) { 
+      if (array[i] > array[i+1]) {
+         printf("erreur");
+         return;
+      }
+   }
+   printf("ok");
+}
+
+int main(int argc,char** argv) {
+   int size = atoi(argv[1]);
+   int seed = atoi(argv[2]);
+   srand(seed);
+   int* res = (int*)malloc(size*sizeof(int));
+   for (int k=0;k<20;k++) {
+      random_tab(size,res,0,100);
+      print(size,res);
+      printf("\n");
+      quicksort(size,res,0,size-1);
+      print(size,res);
+      test_ordre(size,res);
+      printf("\n================\n");
+   }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

source_codes/sorting/tris_base.c

+#include <stdio.h>
+#include <stdlib.h>
+
+void print(int size,int tab[size]);
+void random_tab(int size,int tab[size]);
+void tri_insertion(int size,int tab[size]);
+void tri_bulle(int size,int tab[size]);
+void tri_selection(int size,int tab[size]);
+
+void main(int argc,char** argv) {
+   if (argc != 4) {
+      printf("usage: program <size> <seed> <sorting_algo_number>\n");
+      exit(EXIT_FAILURE);
+   }
+   int size = atoi(argv[1]);
+   int seed = atoi(argv[2]);
+   int choix = atoi(argv[3]);
+   srand(seed);
+   int res[size];
+   random_tab(size,res);
+   print(size,res);
+   printf("\n");
+   switch(choix) {
+      case 1: tri_bulle(size,res); break;
+      case 2: tri_selection(size,res); break;
+      case 3: tri_insertion(size,res); break;
+      default: printf("Choix non available\n");
+   }
+   print(size,res);
+   printf("\n");
+}
+
+void print(int size,int tab[size]) {
+   for (int i=0;i<size;i++) {
+      printf("%d ",tab[i]);
+   }
+}
+
+void random_tab(int size,int tab[size]) {
+   for (int i=0;i<size;i++) {
+      tab[i] = -50+rand()%100;
+   }
+}
+
+void shift(int size,int tab[size],int pos) { 
+   for (int i=size-1;i>pos;i--) {
+      tab[i] = tab[i-1];
+   }
+}
+
+void tri_insertion_step(int sz,int tab[sz],int pos) {
+   int tmp = tab[sz-1];
+   shift(sz,tab,pos);
+   tab[pos] = tmp;
+}    
+
+int position(int size,int tab[size],int val) {
+   int pos = 0;
+   while (pos < size && val > tab[pos]) {
+      pos ++;
+   }
+   return pos;
+}
+
+void tri_insertion(int size,int tab[size]) {
+   for (int i=1;i<size;i++) {
+      int pos = position(i+1,tab,tab[i]);
+      tri_insertion_step(i+1,tab,pos);
+   }
+}
+
+void swap(int* p_a,int* p_b) { 
+   int tmp = *p_a;
+   *p_a = *p_b;
+   *p_b = tmp;
+}
+
+void tri_bulle_step(int size,int tab[size]) {
+   for (int i=0;i<size-1;i++) {
+      if (tab[i] > tab[i+1]) {
+         swap(&tab[i],&tab[i+1]);
+      }
+   }
+}    
+
+void tri_bulle(int size,int tab[size]) {
+   for (int sz=size;sz>=2;sz--) {
+      tri_bulle_step(sz,tab);
+   }
+}    
+
+int index_min(int size,int tab[size],int i) {
+   int ind_min = i;
+   for (int k=i+1;k<size;k++) {
+      if (tab[k] < tab[ind_min]) {
+         ind_min = k;
+      }
+   }
+   return ind_min;
+}
+
+void tri_selection_step(int size,int tab[size],int i) {
+   int ind_min = index_min(size,tab,i);
+   if (tab[i] != tab[ind_min]) {
+      swap(&tab[i],&tab[ind_min]);
+   }
+}    
+
+void tri_selection(int size,int tab[size]) {
+   for (int i=0;i<size-1;i++) {
+      tri_selection_step(size,tab,i);
+   }
+}   
+

source_codes/sorting/tris_base_part.c

+#include <stdio.h>
+#include <stdlib.h>
+  
+// Tri par insertion
+void tri_insertion(int size,int tab[size]);
+// Tri à bulle
+void tri_bulle(int size,int tab[size]);
+// Tri par sélection
+void tri_selection(int size,int tab[size]);
+// Utilitaires
+void print(int size,int tab[size]);
+void random_tab(int size,int tab[size]);
+
+int main(int argc,char** argv) {
+   if (argc != 4) {
+      printf("usage: program <size> <seed> <sorting_algo_number>\n");
+      exit(EXIT_FAILURE);
+   }
+   int size = atoi(argv[1]);
+   int seed = atoi(argv[2]);
+   int choix = atoi(argv[3]);
+   srand(seed);
+   int res[size];
+   random_tab(size,res);
+   print(size,res);
+   printf("\n");
+   switch(choix) {
+      case 1: tri_bulle(size,res); break;
+      case 2: tri_selection(size,res); break;
+      case 3: tri_insertion(size,res); break;
+      default: printf("Choix non available\n");
+   }
+   print(size,res);
+   printf("\n");
+   return EXIT_SUCCESS;
+}
+
+int position(int size,int tab[size],int val) {
+   int pos = 0;
+   while (pos < size && val > tab[pos]) {
+      pos++;
+   }
+   return pos;
+}
+
+void shift(int size,int tab[size],int pos) { 
+   // à compléter
+}
+
+void tri_insertion_step(int sz,int tab[sz],int pos) {
+   int tmp = tab[sz-1];
+   shift(sz,tab,pos);
+   tab[pos] = tmp;
+}
+
+// Tri par insertion
+void tri_insertion(int size,int tab[size]) {
+   // à compléter
+} 
+
+void swap(int* p_a,int* p_b) { 
+   int tmp = *p_a;
+   *p_a = *p_b;
+   *p_b = tmp;
+}
+
+void tri_bulle_step(int size,int tab[size]) {
+   for (int i=0;i<size-1;i++) {
+      if (tab[i] > tab[i+1]) {
+         swap(&tab[i],&tab[i+1]);
+      }
+   }
+}    
+
+// Tri à bulle
+void tri_bulle(int size,int tab[size]) {
+   for (int sz=size;sz>=2;sz--) {
+      tri_bulle_step(sz,tab);
+   }
+}    
+
+int index_min(int size,int tab[size],int i) {
+   int ind_min = i;
+   for (int k=i+1;k<size;k++) {
+      if (tab[k] < tab[ind_min]) {
+         ind_min = k;
+      }
+   }
+   return ind_min;
+}
+
+void tri_selection_step(int size,int tab[size],int i) {
+   // à compléter
+}    
+
+// Tri par sélection
+void tri_selection(int size,int tab[size]) {
+   // à compléter
+}   
+
+void print(int size,int tab[size]) {
+   for (int i=0;i<size;i++) {
+      printf("%d ",tab[i]);
+   }
+}
+
+void random_tab(int size,int tab[size]) {
+   for (int i=0;i<size;i++) {
+      tab[i] = -50+rand()%100;
+   }
+}
+
+
+
+
+
+
+
+
+
+
+