da7e/42-Push_Swap
1
0
Fork 0
mirror of https://github.com/DavidGailleton/42-Push_Swap.git synced 2026-01-27 00:41:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

replacing piles by stacks

Browse Source
This commit is contained in:
Maoake Teriierooiterai
2026-01-09 07:24:32 +01:00
parent 32a0668b62
commit c131843bc0
12 changed files with 101 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
algorithms/medium/medium_algo.c
View File

@@ -14,48 +14,48 @@
#include "medium_headers.h"
#include <stdlib.h>
static int path_to_end(t_stacks *piles, int max_range, int range, char c)
static int path_to_end(t_stacks *stacks, int max_range, int range, char c)
{
t_stack *tmp;
int i;
int first_pass;
if (c == 'a')
tmp = piles->a;
tmp = stacks->a;
else
tmp = piles->b;
tmp = stacks->b;
tmp = tmp->previous;
i = 0;
first_pass = 1;
while (first_pass || tmp != piles->b->previous)
while (first_pass || tmp != stacks->b->previous)
{
first_pass = 0;
if (in_range(tmp->value, max_range, range))
tmp = piles->b;
tmp = stacks->b;
tmp = tmp->previous;
i++;
}
return (i);
}
static int path_to_start(t_stacks *piles, int max_range, int range, char c)
static int path_to_start(t_stacks *stacks, int max_range, int range, char c)
{
t_stack *tmp;
int i;
int first_pass;
if (c == 'a')
tmp = piles->a;
tmp = stacks->a;
else
tmp = piles->b;
tmp = stacks->b;
i = 0;
first_pass = 1;
while (first_pass || tmp != piles->b)
while (first_pass || tmp != stacks->b)
{
first_pass = 0;
if (in_range(tmp->value, max_range, range))
{
tmp = piles->b->previous;
tmp = stacks->b->previous;
}
tmp = tmp->next;
i++;
@@ -63,13 +63,13 @@ static int path_to_start(t_stacks *piles, int max_range, int range, char c)
return (i);
}
int wich_path(t_stacks *piles, int max_range, int range, char c)
int wich_path(t_stacks *stacks, int max_range, int range, char c)
{
int path_start;
int path_end;
path_start = path_to_start(piles, max_range, range, c);
path_end = path_to_end(piles, max_range, range, c);
path_start = path_to_start(stacks, max_range, range, c);
path_end = path_to_end(stacks, max_range, range, c);
if (path_start < path_end)
return (1);
return (0);
@@ -90,16 +90,16 @@ int stack_len(t_stack *stack)
return (i);
}
void bucket_algo(t_stacks *piles, t_tab *preset, int range)
void bucket_algo(t_stacks *stacks, t_tab *preset, int range)
{
t_tab *tmp;
tmp = preset;
while (piles->a)
pb(piles);
while (stacks->a)
pb(stacks);
while (preset)
{
push_range_to_b(piles, preset, range);
push_range_to_b(stacks, preset, range);
if (preset->next)
tmp = preset->next;
else
@@ -108,7 +108,7 @@ void bucket_algo(t_stacks *piles, t_tab *preset, int range)
free(preset);
preset = tmp;
}
while (piles->b)
pa(piles);
while (stacks->b)
pa(stacks);
return ;
}

42
algorithms/medium/sort_utils.c
View File

@@ -13,13 +13,13 @@
#include "push_swap.h"
#include "medium_headers.h"
static int number_move_reverse(t_stacks *piles, int value, char start_end)
static int number_move_reverse(t_stacks *stacks, int value, char start_end)
{
int i;
t_stack *tmp;
i = 0;
tmp = piles->a;
tmp = stacks->a;
if (start_end == 's')
{
while (tmp->value < value)
@@ -40,56 +40,56 @@ static int number_move_reverse(t_stacks *piles, int value, char start_end)
return (i);
}
static int sort_path(t_stacks *piles, int value)
static int sort_path(t_stacks *stacks, int value)
{
int start_path;
int end_path;
start_path = number_move_reverse(piles, value, 's');
start_path = number_move_reverse(stacks, value, 's');
if (start_path == 0)
return (1);
end_path = number_move_reverse(piles, value, 'e');
end_path = number_move_reverse(stacks, value, 'e');
if (start_path < end_path)
return (1);
return (0);
}
static void sort_little_pile(t_stacks *piles)
static void sort_little_pile(t_stacks *stacks)
{
if (!piles->a)
if (!stacks->a)
{
pa(piles);
pa(stacks);
return ;
}
if (piles->a->previous->value < piles->b->value)
if (stacks->a->previous->value < stacks->b->value)
{
pa(piles);
ra(piles);
pa(stacks);
ra(stacks);
return ;
}
if (sort_path(piles, piles->b->value))
sort_from_left(piles);
if (sort_path(stacks, stacks->b->value))
sort_from_left(stacks);
else
sort_from_right(piles);
sort_from_right(stacks);
}
void push_range_to_b(t_stacks *piles, t_tab *one_preset, int range)
void push_range_to_b(t_stacks *stacks, t_tab *one_preset, int range)
{
while (one_preset->nb_in > 0)
{
if (wich_path(piles, one_preset->max_range, range, 'b'))
if (wich_path(stacks, one_preset->max_range, range, 'b'))
{
while (!in_range(piles->b->value, one_preset->max_range, range))
rb(piles);
while (!in_range(stacks->b->value, one_preset->max_range, range))
rb(stacks);
}
else
{
while (!in_range(piles->b->value, one_preset->max_range, range))
while (!in_range(stacks->b->value, one_preset->max_range, range))
{
rrb(piles);
rrb(stacks);
}
}
sort_little_pile(piles);
sort_little_pile(stacks);
one_preset->nb_in--;
}
}

20
algorithms/medium/sort_utils_two.c
View File

@@ -12,38 +12,38 @@
#include "push_swap.h"
void sort_from_left(t_stacks *piles)
void sort_from_left(t_stacks *stacks)
{
int i;
i = 0;
while (piles->b->value > piles->a->value)
while (stacks->b->value > stacks->a->value)
{
ra(piles);
ra(stacks);
i++;
}
pa(piles);
pa(stacks);
while (i > 0)
{
rra(piles);
rra(stacks);
i--;
}
}
void sort_from_right(t_stacks *piles)
void sort_from_right(t_stacks *stacks)
{
int i;
i = 0;
while (piles->b->value < piles->a->previous->value)
while (stacks->b->value < stacks->a->previous->value)
{
rra(piles);
rra(stacks);
i++;
}
pa(piles);
pa(stacks);
while (i >= 0)
{
ra(piles);
ra(stacks);
i--;
}
}

32
flags/algorithms_sort.c
View File

@@ -13,41 +13,41 @@
#include "push_swap.h"
#include "medium_headers.h"
void simple(t_stacks *piles)
void simple(t_stacks *stacks)
{
int len;
len = stack_a_len(piles);
piles->algo = 1;
insertion(piles, len);
len = stack_a_len(stacks);
stacks->algo = 1;
insertion(stacks, len);
}
void medium(t_stacks *piles)
void medium(t_stacks *stacks)
{
t_tab *buckets;
int range;
int len;
piles->algo = 2;
len = stack_a_len(piles);
stacks->algo = 2;
len = stack_a_len(stacks);
if (len == 2)
sort_two(piles);
sort_two(stacks);
else
{
range = range_bucket(piles->a);
buckets = get_tabs(piles->a, range);
bucket_algo(piles, buckets, range);
range = range_bucket(stacks->a);
buckets = get_tabs(stacks->a, range);
bucket_algo(stacks, buckets, range);
}
}
void complex(t_stacks *piles)
void complex(t_stacks *stacks)
{
piles->algo = 3;
radix(piles);
stacks->algo = 3;
radix(stacks);
}
void adaptive(t_stacks *piles)
void adaptive(t_stacks *stacks)
{
(void)piles;
(void)stacks;
return ;
}

14
flags/flag.c
View File

@@ -93,18 +93,18 @@ int pos_bench(char **argv, int mod)
return (0);
}
void flags(int pos, int pos_b, char **argv, t_stacks *piles)
void flags(int pos, int pos_b, char **argv, t_stacks *stacks)
{
if (ft_strncmp(argv[pos], "--simple", 30) && pos > 0)
simple(piles);
simple(stacks);
else if (ft_strncmp(argv[pos], "--medium", 30) && pos > 0)
medium(piles);
medium(stacks);
else if (ft_strncmp(argv[pos], "--complex", 30) && pos > 0)
complex(piles);
complex(stacks);
else if (ft_strncmp(argv[pos], "--adaptive", 30) && pos > 0)
adaptive(piles);
adaptive(stacks);
else
adaptive(piles);
adaptive(stacks);
if (pos_b > 0)
piles->bench = 1;
stacks->bench = 1;
}

10
headers/flags.h
View File

@@ -13,11 +13,11 @@
#ifndef FLAGS_H
# define FLAGS_H
void simple(t_stacks *piles);
void medium(t_stacks *piles);
void complex(t_stacks *piles);
void adaptive(t_stacks *piles);
void flags(int pos, int pos_b, char **argv, t_stacks *piles);
void simple(t_stacks *stacks);
void medium(t_stacks *stacks);
void complex(t_stacks *stacks);
void adaptive(t_stacks *stacks);
void flags(int pos, int pos_b, char **argv, t_stacks *stacks);
int pos_bench(char **argv, int mod);
int pos_flag(char **argv, int mod);
int calcul_mod(int argc, char **argv);

10
headers/medium_headers.h
View File

@@ -21,13 +21,13 @@ typedef struct s_tab
} t_tab;
/* MEDIUM ALGO FILE */
int wich_path(t_stacks *piles, int max_range, int range, char c);
int wich_path(t_stacks *stacks, int max_range, int range, char c);
int stack_len(t_stack *stack);
void bucket_algo(t_stacks *piles, t_tab *preset, int range);
void bucket_algo(t_stacks *stacks, t_tab *preset, int range);
/* SORT UTILS FILES */
void sort_from_left(t_stacks *piles);
void sort_from_right(t_stacks *piles);
void push_range_to_b(t_stacks *piles, t_tab *one_preset, int range);
void sort_from_left(t_stacks *stacks);
void sort_from_right(t_stacks *stacks);
void push_range_to_b(t_stacks *stacks, t_tab *one_preset, int range);
/* MEDIUM UTILS FILES */
int range_bucket(t_stack *first);
int get_first_lower(t_stack *first);

2
headers/parsing.h
View File

@@ -17,7 +17,7 @@
# include "push_swap.h"
int ft_atoi(const char *nptr);
t_stacks *init_piles(int argc, char **argv, int mod);
t_stacks *init_stacks(int argc, char **argv, int mod);
int ft_strncmp(const char *s1, const char *s2, int n);
size_t ft_strlen(const char *s);
char *ft_substr(char const *s, unsigned int start, size_t len);

2
headers/push_swap.h
View File

@@ -59,7 +59,7 @@ t_stack *new_stack(int value);
void stack_add_back(t_stack **stack, t_stack *new);
void stack_add_front(t_stack **stack, t_stack *new);
void stack_clear_all(t_stack *stack, t_stack *first);
void free_all(t_stacks *piles);
void free_all(t_stacks *stacks);
/* STACKS LEN FILES */
int stack_a_len(t_stacks *stacks);
int stack_b_len(t_stacks *stacks);

2
parsing/parsing.c
View File

@@ -93,7 +93,7 @@ static void set_t_stacks(t_stacks *stacks)
stacks->rrr = 0;
}
t_stacks *init_piles(int argc, char **argv, int mod)
t_stacks *init_stacks(int argc, char **argv, int mod)
{
t_stacks *stacks;
t_stack *a;

12
stack_utils/stack_remove.c
View File

@@ -22,11 +22,11 @@ void stack_clear_all(t_stack *stack, t_stack *first)
free(stack);
}
void free_all(t_stacks *piles)
void free_all(t_stacks *stacks)
{
if (piles->a)
stack_clear_all(piles->a, piles->a);
if (piles->b)
stack_clear_all(piles->b, piles->b);
free(piles);
if (stacks->a)
stack_clear_all(stacks->a, stacks->a);
if (stacks->b)
stack_clear_all(stacks->b, stacks->b);
free(stacks);
}

18
test_one.c
View File

@@ -19,21 +19,21 @@
int test1(int argc, char **argv)
{
t_stacks *piles;
t_stacks *stacks;
int mod;
piles = NULL;
stacks = NULL;
mod = calcul_mod(argc, argv);
if (mod == -1)
return (0);
piles = init_piles(argc, argv, mod);
if (!piles)
stacks = init_stacks(argc, argv, mod);
if (!stacks)
return (0);
if (check_order(piles->a))
if (check_order(stacks->a))
return (0);
flags(pos_flag(argv, mod), pos_bench(argv, mod), argv, piles);
if (piles->bench == 1)
print_bench(piles);
free_all(piles);
flags(pos_flag(argv, mod), pos_bench(argv, mod), argv, stacks);
if (stacks->bench == 1)
print_bench(stacks);
free_all(stacks);
return (0);
}