
source des comparaisons ci-dessous : [https://www.youtube.com/watch?v=xoR-1KwQh2k](https://www.youtube.com/watch?v=xoR-1KwQh2k)


    numbers  comparisons  array-access  name
        200       19 900        18 448  Bubble Sort
        200       20 000        20 384  Cocktail Shaker Sort
        200       19 501        19 306  Gnome Sort
        200        9 568        18 752  Optimized Gnome Sort
       2000       18 308        18 498  Odd-Even Sort
       2000    1 999 000         3 998  Selection Sort
       2000    2 002 000         4 000  Double Selection Sort
       2000      965 671    19 273 364  Insertion Sort
       2000       19 201     1 890 122  Binary Insertion Sort
       2000       53 378        20 574  Comb Sort
       2000       31 948        32 789  Shell Sort
       2000       19 423        43 904  Merge Sort
       2000       31 048        59 938  Binary Merge
       2000      100 955     2 156 938  Weave Merge Sort
       2000       19 496        43 039  TimSort
       2000    1 993 119     1 930 836  Merge Sort In-Place
       2000       31 022       111 758  WikiSort (Block Merge Sort)
       2000       22 193        85 044  GrailSort (Block Merge Sort)
       2000       30 905        10 510  Quick Sort
       2000       26 160        27 488  Stable Quick Sort
       2000       24 482        18 852  Dual Pivot Quick Sort
       2000       37 841        40 490  Max Heap Sort
       2000       37 714        42 206  Min Heap Sort
       2000       21 021        26 756  Weak Heap Sort
       2000       24 996        27 926  Ternary Heap Sort
       2000       50 078        27 803  Smooth Sort
       2000       19 410         2 000  Tournament Sort
       2000    5 935 671         3 996  Cycle Sort
       2000       25 711        16 616  std::sort (Introsort)
       2048       33 352        25 109  Quick Shell Sort (Introsort with Shellsort)
       2048       19 821        31 652  std::stable sort (Insert/Bottom-up Merge)
       2000       58 367        66 296  Batcher's Odd-Even Mergesort
       2000       64 832        66 118  Batcher's Bitonic Sort
        200       20 099        30 684  Pancake Sort
       2000       54 989         2 000  Patience Sort
       2000            0     3 973 224  Gravity Sort
       2000            0         6 000  Counting Sort
       2000            0         4 000  Pigeonhole Sort
       2000            0        12 000  Radix LSD Sort (Base 4)
       2000            0         4 220  American Flag Sort (128 Buckets)
       2048            0    19 207 376  Radix LSD In-Place Sort (Base 10)
       2000            0    34 562 144  Radix LSD In-Place Sort (Base 2)
       2000            0        26 000  Radix MSD Sort (Base 4)
       2000            0        46 000  Radix MSD Sort (Base 2)
       2000            0        80 048  Shatter Sort
       2000            0        12 000  Simple Shatter Sort
       2000        5 044         6 098  Flash Sort
       2000       28 868        55 742  Time Sort (Mul 4) + Insertion Sort
        200      797 161        19 928  Stooge Sort
        200       50 783           400  Bad Sort
        200  114 006 565        19 276  Silly Sort
        200  114 006 565        20 716  Slow Sort
        200      100 437     4 771 028  Less Bogo Sort
        200      131 994     2 472 298  Cocktail Bogo Sort
         10    4 875 249    56 784 400  Bogo Sort


---

autre source de comparaison : [https://www.toptal.com/developers/sorting-algorithms](https://www.toptal.com/developers/sorting-algorithms)
push_swap_visalizer : [https://github.com/o-reo/push_swap_visualizer](https://github.com/o-reo/push_swap_visualizer)

---

## pour utiliser l'algorithme de tris de ce programme dans votre propre programme, il faut :

1. copier le fichier algo.c

2. mettre son prototype dans votre header.h : `void hugo_sort(t_stack **a, t_stack **b, t_list **solution)`

3. mettre le fichier dans vos srcs dans Makefile (`algo.c`)

4. et verifier que vos functions d'actions (push, swap, rotate) ont bien les memes prototypes :
	- `t_list *sa(t_stack **stack, t_list **lst);`
	- `t_list *ss(t_stack **a, t_stack **b, t_list **lst);`
	- `t_list *pa(t_stack **dst, t_stack **src, t_list **lst);`
	- `t_list *pb(t_stack **dst, t_stack **src, t_list **lst);`
	- `t_list *ra(t_stack **stack, t_list **lst);`
	- `t_list *rb(t_stack **stack, t_list **lst);`
	- `t_list *rr(t_stack **a, t_stack **b, t_list **lst);`
	- `t_list *rra(t_stack **stack, t_list **lst);`
	- `t_list *rrb(t_stack **stack, t_list **lst);`
	- `t_list *rrr(t_stack **a, t_stack **b, t_list **lst);`

## points particuliers :

- les fonctions d'actions (puches, swapes, rotates) recoivent une ou les deux piles a et b, et la liste chainee *solution* qui doit accueillir les noms des actions successives
- mais pour pouvoir imprimer l'état des deux piles a et b a chaque etape il faudrait que chaques fonctions recoivent les deux piles, ce qui n'est pas le cas : sa() par exemple ne recoit pas la pile b
- donc j'ai stocké les deux piles dans les deux premiers maillons de la chaine solution, car toutes les fonctions d'actions la recoivent

## ce programme push_swap.c s'organise de la facon suivante :

1. des fonctions pour faire fonctionner l'algorithme de tris (principalement parsing des donnees, et les actions utilisees par l'algorithme de tris : push, swap, rotate et reverse rotate) :

- **push_swap.c** : contient la fonction main et 4 autres fonctions :
	- **is_valid** : verification d'erreur dans les arguments données, si aucun argument affiche l'usage
	- **check_flag** : regarde la presence des flags, pour l'instant uniquement -p pour print les etapes du tri
	- **init_stack** : parse la pile a trier dans une liste chainee
	- **launch_algo** : lance l'algorithme de tri, en lui envoyant ce qui est necessaire (les deux piles a et b et la liste de solutions)

- **stop.c** : qui gere les erreurs, l'usage, mais aussi qui free avant de fermer le programme
	- **ps_stop** : recoit toutes les listes chainees du programme, envoyer NULL si on ne veut pas free la liste, et le dernier int permet de savoir si on veut juste free sans arreter le programme (= -1), et si on veut signaler une erreur (>= 1)
	- **ps_error** : la gestion des erreurs
	- **ps_usage** : en cas d'erreur = 1, affiche l'usage du programme

- **print.c** : contient les fonctions necessaires pour afficher le resultat
	- **print_result** : affiche le resultat, et si presence du flag -p affiche aussi les etapes de tris
	- **fill_solution** : remplit la liste chainee solution au fur et a mesure de l'appel des fonctions push swap et rotate (pas optimisé pour raison de compatibilité avec l'appel des fonctions du programme de luke : les actions (push, swap, etc) ne recoivent pas de flag en argument, donc fill_solution remplis toutes les infos necessaires pour le flag, meme s'il n'y a pas de flag)

- toutes les fonctions d'action (push, swap, rotate, et reverse rotate)


2. les fonctions d'algorithme, qui sont appellees par launch_solution()

- **algo.c** : le fichier qui contient les fonctions d'algorithme de tri
	- **hugo_sort** : pour l'instant une fonction test qui utilise toutes les actions (push, swap, rotate)




