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

Merge branch 'medium_algo'

Browse Source
This commit is contained in:
Maoake Teriierooiterai
2026-01-06 13:53:48 +01:00
parent 508b63d296 80179a5289
commit ef9f16a142
16 changed files with 830 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
algorithms/medium_algo.c Normal file
View File

@@ -0,0 +1,115 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* medium_algo.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 07:14:45 by mteriier #+# #+# */
/* Updated: 2025/12/10 07:14:51 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include <stdlib.h>
int path_to_end(t_stacks *piles, int max_range, int range, char c)
{
t_stack *tmp;
int i;
int first_pass;
if (c == 'a')
tmp = piles->a;
else
tmp = piles->b;
tmp = tmp->previous;
i = 0;
first_pass = 1;
while (first_pass || tmp != piles->b->previous)
{
first_pass = 0;
if (in_range(tmp->value, max_range, range))
tmp = piles->b;
tmp = tmp->previous;
i++;
}
return (i);
}
int path_to_start(t_stacks *piles, int max_range, int range, char c)
{
t_stack *tmp;
int i;
int first_pass;
if (c == 'a')
tmp = piles->a;
else
tmp = piles->b;
i = 0;
first_pass = 1;
while (first_pass || tmp != piles->b)
{
first_pass = 0;
if (in_range(tmp->value, max_range, range))
{
tmp = piles->b->previous;
}
tmp = tmp->next;
i++;
}
return (i);
}
int wich_path(t_stacks *piles, 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);
if (path_start < path_end)
return (1);
return (0);
}
int stack_len(t_stack *stack)
{
t_stack *first;
int i;
first = stack;
i = 1;
while (first->next != stack)
{
first = first->next;
i++;
}
return (i);
}
void bucket_algo(t_stacks *piles, t_tab *preset, int range)
{
t_tab *tmp;
tmp = preset;
while (piles->a)
pb(piles);
while (preset)
{
push_range_to_b(piles, preset, range);
if (preset->next)
tmp = preset->next;
else
tmp = NULL;
if (preset)
free(preset);
preset = tmp;
}
while (piles->b)
pa(piles);
print_all_stack(piles->a, piles->a, 'A');
print_all_stack(piles->b, piles->b, 'B');
return ;
}

96
algorithms/medium_utils/sort_utils.c Normal file
View File

@@ -0,0 +1,96 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/05 14:11:49 by mteriier #+# #+# */
/* Updated: 2026/01/05 14:11:52 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
void push_range_to_b(t_stacks *piles, t_tab *one_preset, int range)
{
while (one_preset->nb_in > 0)
{
if (wich_path(piles, one_preset->max_range, range, 'b'))
{
while (!in_range(piles->b->value, one_preset->max_range, range))
rb(piles);
}
else
{
while (!in_range(piles->b->value, one_preset->max_range, range))
{
rrb(piles);
}
}
sort_little_pile(piles);
one_preset->nb_in--;
}
print_all_stack(piles->a, piles->a, 'A');
print_all_stack(piles->b, piles->b, 'B');
}
int sort_path(t_stacks *piles, int value)
{
int start_path;
int end_path;
start_path = number_move_reverse(piles, value, 's');
if (start_path == 0)
return (1);
end_path = number_move_reverse(piles, value, 'e');
if (start_path < end_path)
return (1);
return (0);
}
int number_move_reverse(t_stacks *piles, int value, char start_end)
{
int i;
t_stack *tmp;
i = 0;
tmp = piles->a;
if (start_end == 's')
{
while (tmp->value < value)
{
tmp = tmp->next;
i++;
}
}
else
{
tmp = tmp->previous;
while (tmp->value > value)
{
tmp = tmp->previous;
i++;
}
}
return (i);
}
void sort_little_pile(t_stacks *piles)
{
if (!piles->a)
{
pa(piles);
return ;
}
if (piles->a->previous->value < piles->b->value)
{
pa(piles);
ra(piles);
return ;
}
if (sort_path(piles, piles->b->value))
sort_from_left(piles);
else
sort_from_right(piles);
}

49
algorithms/medium_utils/sort_utils_two.c Normal file
View File

@@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort_utils_two.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/06 07:52:36 by mteriier #+# #+# */
/* Updated: 2026/01/06 07:52:38 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
void sort_from_left(t_stacks *piles)
{
int i;
i = 0;
while (piles->b->value > piles->a->value)
{
ra(piles);
i++;
}
pa(piles);
while (i > 0)
{
rra(piles);
i--;
}
}
void sort_from_right(t_stacks *piles)
{
int i;
i = 0;
while (piles->b->value < piles->a->previous->value)
{
rra(piles);
i++;
}
pa(piles);
while (i >= 0)
{
ra(piles);
i--;
}
}

93
algorithms/medium_utils/utils_medium.c Normal file
View File

@@ -0,0 +1,93 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils_medium.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 13:58:40 by mteriier #+# #+# */
/* Updated: 2025/12/10 13:58:42 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int get_first_lower(t_stack *first)
{
t_stack *tmp;
int lower;
tmp = first;
lower = tmp->value;
while (tmp->next != first)
{
if (lower > tmp->value)
lower = tmp->value;
tmp = tmp->next;
}
return (lower);
}
int get_next_lower(t_stack *first, int old_lower)
{
t_stack *tmp;
int next_lower;
tmp = first;
next_lower = 2147483647;
while (tmp->next != first)
{
if (old_lower < tmp->value && tmp->value <= next_lower)
{
next_lower = tmp->value;
}
tmp = tmp->next;
}
return (next_lower);
}
int calcul_range(int value, int range)
{
int max_range;
max_range = 0;
if (value < 0)
while (max_range > value)
max_range -= range;
else
while (max_range <= value)
max_range += range;
if (max_range < 0)
return (max_range + range - 1);
return (max_range - 1);
}
int in_range(int value, int max_range, int range)
{
int min_range;
min_range = max_range - (range - 1);
if (value <= max_range && value >= min_range)
return (1);
return (0);
}
int get_number_in_range(int max_range, t_stack *a, int range)
{
int nb_in;
t_stack *tmp;
t_stack *first;
nb_in = 0;
tmp = a;
first = tmp;
while (tmp->next != first)
{
if (in_range(tmp->value, max_range, range))
nb_in++;
tmp = tmp->next;
}
if (in_range(tmp->value, max_range, range))
nb_in++;
return (nb_in);
}

65
algorithms/medium_utils/utils_medium_two.c Normal file
View File

@@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils_medium_two.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.lyon42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/22 09:36:56 by mteriier #+# #+# */
/* Updated: 2025/12/22 09:38:19 by mteriier ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int get_max_number(t_stack *first)
{
int max;
t_stack *a;
a = first;
max = a->value;
while (a->next != first)
{
if (max < a->value)
max = a->value;
a = a->next;
}
return (max);
}
int get_min_number(t_stack *first)
{
int min;
t_stack *a;
a = first;
min = a->value;
while (a->next != first)
{
if (min > a->value)
min = a->value;
a = a->next;
}
return (min);
}
int my_sqrt(int nb)
{
int i;
if (nb < 1)
return (0);
i = 0;
while (i * i <= nb)
i++;
return (i);
}
int range_bucket(t_stack *first)
{
int len;
len = stack_len(first);
return ((get_max_number(first) - get_min_number(first)) / my_sqrt(len));
}

88
algorithms/medium_utils/utils_struct_tab.c Normal file
View File

@@ -0,0 +1,88 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils_struct_tab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 13:36:43 by mteriier #+# #+# */
/* Updated: 2025/12/10 13:36:48 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include <stdlib.h>
t_tab *allocate_tab(int range_max, int nb)
{
t_tab *tab;
tab = malloc(sizeof(t_tab));
if (!tab)
return (NULL);
tab->next = NULL;
tab->max_range = range_max;
tab->nb_in = nb;
return (tab);
}
t_tab *get_tabs(t_stack *first, int range)
{
t_tab *tmp;
t_tab *first_tab;
int len_stack;
int scan_nb_in_tab;
len_stack = stack_len(first);
first_tab = init_first_tab(first, range);
if (!first_tab)
return (NULL);
scan_nb_in_tab = first_tab->nb_in;
tmp = first_tab;
while (scan_nb_in_tab < len_stack)
{
tmp->next = get_next_tab(first, tmp, range);
if (!(tmp->next))
return (free_tab(&first_tab));
tmp = tmp->next;
scan_nb_in_tab += tmp->nb_in;
}
return (first_tab);
}
t_tab *init_first_tab(t_stack *first, int range)
{
t_tab *tab;
int lower;
int range_max;
lower = get_first_lower(first);
range_max = calcul_range(lower, range);
tab = allocate_tab(range_max, get_number_in_range(range_max, first, range));
if (!tab)
return (NULL);
return (tab);
}
t_tab *get_next_tab(t_stack *first, t_tab *tab, int range)
{
int lower;
int range_max;
t_tab *next_tab;
lower = get_next_lower(first, tab->max_range);
range_max = calcul_range(lower, range);
next_tab = allocate_tab(range_max,
get_number_in_range(range_max, first, range));
return (next_tab);
}
t_tab *free_tab(t_tab **first)
{
if (!(*first))
return (NULL);
if ((*first)->next)
free_tab(&(*first)->next);
free(*first);
return (NULL);
}

2
algorithms/utils/compare.c
View File

@@ -41,5 +41,3 @@ int is_highest(t_stack *stack, t_stack *node, int len)
}
return (1);
}

20
algorithms/utils/compare_value.c Normal file
View File

@@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* compare_value.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 11:08:35 by mteriier #+# #+# */
/* Updated: 2025/12/10 11:28:58 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int is_upper_compare(t_stack *t1, t_stack *t2)
{
if (t1->value > t2->value)
return (1);
return (0);
}