42/42_INT_06_pushwap
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

algo recursive fonctionne manque le tris des mini listes

Browse Source
This commit is contained in:
hugogogo
2021-09-25 17:19:07 +02:00
parent 38a5a88d8a
commit 115c03b8ca
9 changed files with 154 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
README.md
View File

@@ -1,3 +1,74 @@
## description du programme :
**sa** : swap a - intervertit les 2 premiers éléments au sommet de la pile a. Ne fait rien s’il n’y en a qu’un ou aucun.
**sb** : swap b - intervertit les 2 premiers éléments au sommet de la pile b. Ne fait rien s’il n’y en a qu’un ou aucun.
**ss** : sa et sb en même temps.
**pa** : push a - prend le premier élément au sommet de b et le met sur a. Ne fait rien si b est vide.
**pb** : push b - prend le premier élément au sommet de a et le met sur b. Ne fait rien si a est vide.
**ra** : rotate a - décale d’une position vers le haut tous les élements de la pile a. Le premier élément devient le dernier.
**rb** : rotate b - décale d’une position vers le haut tous les élements de la pile b. Le premier élément devient le dernier.
**rr** : ra et rb en même temps.
**rra** : reverse rotate a - décale d’une position vers le bas tous les élements de la pile a. Le dernier élément devient le premier.
**rrb** : reverse rotate b - décale d’une position vers le bas tous les élements de la pile b. Le dernier élément devient le premier.
**rrr** : rra et rrb en même temps.
## 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 **a, 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)
## comparaison des algorithmes de tris :
source des comparaisons ci-dessous : [https://www.youtube.com/watch?v=xoR-1KwQh2k](https://www.youtube.com/watch?v=xoR-1KwQh2k)
@@ -67,59 +138,3 @@ push_swap_visalizer : [https://github.com/o-reo/push_swap_visualizer](https://gi
---
## 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)

BIN
builds/algo.o
View File

Binary file not shown.

BIN
builds/print.o
View File

Binary file not shown.

BIN
builds/push_swap.o
View File

Binary file not shown.

2
includes/push_swap.h
View File

@@ -42,7 +42,7 @@ void hugo_sort(t_stack **a, t_stack **b, t_list *lst);
/*
** print.c
*/
void mark_step(t_list *solution);
void mark_step(t_list *solution, char *step);
void fill_solution(t_list *lst, char *s);
char *fill_line(t_stack *list, char *stack);
void print_result(t_list *lst, int i);

BIN
push_swap
View File

Binary file not shown.

70
srcs/algo.c
View File

@@ -56,37 +56,74 @@ int find_pivot(t_stack *list, int size)
int divide_a(t_stack **a, t_stack **b, t_list *solution)
{
int list_size;
int pivot;
int list_size;
int pivot;
t_stack *first_rotate;
(void)b;
(void)solution;
first_rotate = NULL;
list_size = sublist_size(*a);
pivot = find_pivot(*a, list_size);
(*a)->limit = 0;
while (list_size-- > 0)
{
if ((*a)->n >= pivot)
{
if (!first_rotate)
first_rotate = *a;
ra(a, &solution);
}
else
pb(b, a, &solution);
}
mark_step(solution);
while (*a != first_rotate)
rra(a, &solution);
(*a)->limit = 1;
(*b)->limit = 1;
mark_step(solution, "divide_a");
return (0);
}
int divide_b(t_stack **a, t_stack **b, t_list *solution)
{
(void)a;
(void)b;
(void)solution;
int list_size;
int pivot;
t_stack *first_rotate;
first_rotate = NULL;
list_size = sublist_size(*b);
pivot = find_pivot(*b, list_size);
(*b)->limit = 0;
while (list_size-- > 0)
{
if ((*b)->n >= pivot)
pa(a, b, &solution);
else
{
if (!first_rotate)
first_rotate = *b;
rb(b, &solution);
}
}
while (*b != first_rotate)
rrb(b, &solution);
(*a)->limit = 1;
(*b)->limit = 1;
mark_step(solution, "divide_b");
return (0);
}
void send_sublist_to_a(t_stack **a, t_stack **b, t_list *solution)
{
(void)a;
(void)b;
(void)solution;
int list_size;
list_size = sublist_size(*b);
(*b)->limit = 0;
while (list_size-- > 0)
pa(a, b, &solution);
(*a)->limit = 1;
if (*b)
(*b)->limit = 1;
mark_step(solution, "send_sublist_to_a");
}
void mini_sort(t_stack **a, t_stack **b, t_list *solution)
@@ -98,19 +135,18 @@ void mini_sort(t_stack **a, t_stack **b, t_list *solution)
void hugo_sort(t_stack **a, t_stack **b, t_list *solution)
{
if (sublist_size(*a) > 5)
divide_a(a, b, solution);
/*
if (sublist_size(*a) > 3)
divide_a(a, b, solution);
else if (sublist_size(*b) > 3)
else if (sublist_size(*b) > 5)
{
mini_sort(a, b, solution);
divide_b(a, b, solution);
}
else
else if (sublist_size(*b) > 0)
send_sublist_to_a(a, b, solution);
else
return ;
hugo_sort(a, b, solution);
*/
}
// /*

38
srcs/print.c
View File

@@ -7,22 +7,21 @@ char *fill_line(t_stack *list, char *stack)
if (list->limit == 1)
stack = ft_strjoinfree(ft_strdup("]"), stack);
stack = ft_strjoinfree(ft_itoa(list->n), stack);
if (list->limit == 1)
stack = ft_strjoinfree(ft_strdup("["), stack);
stack = ft_strjoinfree(ft_strdup(" "), stack);
list = list->next;
}
return (stack);
}
void mark_step(t_list *solution)
void mark_step(t_list *solution, char *step)
{
char *line;
while (solution->next != NULL)
solution = solution->next;
line = solution->content;
line = ft_strjoinfree(line, ft_strdup("!1"));
line = ft_strjoinfree(line, ft_strdup("!"));
line = ft_strjoinfree(line, ft_strdup(step));
solution->content = line;
}
@@ -62,6 +61,28 @@ void fill_solution(t_list *solution, char *sp)
ft_lstadd_back(&solution, ft_lstnew(stack));
}
// some drafty code to print sublist with flag
void print_flags(char **part, int flag)
{
int last_a;
int last_b;
last_a = part[1][ft_strlen(part[1]) - 1];
last_b = part[0][ft_strlen(part[0]) - 1];
if (flag && part[3] != NULL)
ft_printf(" ( %s )", part[3]);
if (flag == 1 || (flag == 2 && part[3] != NULL))
{
ft_printf("\n %s", part[1]);
if (part[3] != NULL && last_a != ']')
ft_putchar(']');
ft_printf("\n %s", part[0]);
if (part[3] != NULL && last_b != ']' && last_b != ':')
ft_putchar(']');
}
}
void print_result(t_list *result, int flag)
{
int i;
@@ -73,12 +94,9 @@ void print_result(t_list *result, int flag)
{
i++;
part = ft_split(result->content, '!');
ft_printf("%s\n", part[2]);
if (flag == 1 || (flag == 2 && part[3] != NULL))
{
ft_printf(" %s\n", part[1]);
ft_printf(" %s\n", part[0]);
}
ft_printf("%s", part[2]);
print_flags(part, flag);
ft_putchar('\n');
result = result->next;
free(part[0]);
free(part[1]);

3
srcs/push_swap.c
View File

@@ -41,7 +41,6 @@ t_stack *init_stack(int ac, char **av)
start->next = tmp;
tmp = start;
}
start->limit = 1;
return (start);
}
@@ -58,7 +57,7 @@ t_list *launch_algo(t_stack **a, t_stack **b, int flag)
if (flag)
{
fill_solution(solution, "start");
mark_step(solution);
mark_step(solution, "start");
}
hugo_sort(a, b, solution);
// bubble_sort(a, b, solution);