From 1416359bb4d72dbc18bc74307c7137f2680af8aa Mon Sep 17 00:00:00 2001
From: "paul.albuquer" <paul.albuquerque@hesge.ch>
Date: Mon, 18 Oct 2021 15:46:55 +0200
Subject: [PATCH] added sorting codes
---
source_codes/sorting/heapsort.c | 62 +++++++++++++
source_codes/sorting/heapsort.h | 11 +++
source_codes/sorting/heapsort_main.c | 38 ++++++++
source_codes/sorting/heapsort_part.c | 45 ++++++++++
source_codes/sorting/quicksort.c | 70 +++++++++++++++
source_codes/sorting/quicksort_part.c | 99 +++++++++++++++++++++
source_codes/sorting/tris_base.c | 114 ++++++++++++++++++++++++
source_codes/sorting/tris_base_part.c | 122 ++++++++++++++++++++++++++
8 files changed, 561 insertions(+)
create mode 100644 source_codes/sorting/heapsort.c
create mode 100644 source_codes/sorting/heapsort.h
create mode 100644 source_codes/sorting/heapsort_main.c
create mode 100644 source_codes/sorting/heapsort_part.c
create mode 100644 source_codes/sorting/quicksort.c
create mode 100644 source_codes/sorting/quicksort_part.c
create mode 100644 source_codes/sorting/tris_base.c
create mode 100644 source_codes/sorting/tris_base_part.c
diff --git a/source_codes/sorting/heapsort.c b/source_codes/sorting/heapsort.c
new file mode 100644
index 0000000..d65e567
--- /dev/null
+++ b/source_codes/sorting/heapsort.c
@@ -0,0 +1,62 @@
+#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;
+}
+
+
diff --git a/source_codes/sorting/heapsort.h b/source_codes/sorting/heapsort.h
new file mode 100644
index 0000000..2f88d6c
--- /dev/null
+++ b/source_codes/sorting/heapsort.h
@@ -0,0 +1,11 @@
+#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
diff --git a/source_codes/sorting/heapsort_main.c b/source_codes/sorting/heapsort_main.c
new file mode 100644
index 0000000..a1b8cfc
--- /dev/null
+++ b/source_codes/sorting/heapsort_main.c
@@ -0,0 +1,38 @@
+#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;
+ }
+}
+
+
diff --git a/source_codes/sorting/heapsort_part.c b/source_codes/sorting/heapsort_part.c
new file mode 100644
index 0000000..a50fba7
--- /dev/null
+++ b/source_codes/sorting/heapsort_part.c
@@ -0,0 +1,45 @@
+#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;
+}
+
+
diff --git a/source_codes/sorting/quicksort.c b/source_codes/sorting/quicksort.c
new file mode 100644
index 0000000..95943c5
--- /dev/null
+++ b/source_codes/sorting/quicksort.c
@@ -0,0 +1,70 @@
+#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");
+ }
+}
+
diff --git a/source_codes/sorting/quicksort_part.c b/source_codes/sorting/quicksort_part.c
new file mode 100644
index 0000000..d7e0868
--- /dev/null
+++ b/source_codes/sorting/quicksort_part.c
@@ -0,0 +1,99 @@
+#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");
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/source_codes/sorting/tris_base.c b/source_codes/sorting/tris_base.c
new file mode 100644
index 0000000..dfbd099
--- /dev/null
+++ b/source_codes/sorting/tris_base.c
@@ -0,0 +1,114 @@
+#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);
+ }
+}
+
diff --git a/source_codes/sorting/tris_base_part.c b/source_codes/sorting/tris_base_part.c
new file mode 100644
index 0000000..f41a20e
--- /dev/null
+++ b/source_codes/sorting/tris_base_part.c
@@ -0,0 +1,122 @@
+#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;
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
--
GitLab