692 lines
11 KiB
C
692 lines
11 KiB
C
#include "push_swap.h"
|
|
|
|
int last_element(t_stack *a)
|
|
{
|
|
while (a->next)
|
|
a = a->next;
|
|
return (a->n);
|
|
}
|
|
|
|
// size is initialized to 1 because the loop check the next element, so it will end one step before reaching it
|
|
// it checks the next one to avoid handle the first one with ->limit set to 1
|
|
int sublist_size(t_stack *list)
|
|
{
|
|
int size;
|
|
|
|
if (list == NULL)
|
|
return (0);
|
|
size = 1;
|
|
while (list->next != NULL && list->next->limit != 1)
|
|
{
|
|
list = list->next;
|
|
size++;
|
|
}
|
|
return (size);
|
|
}
|
|
|
|
int nbr_element_smaller(t_stack *list, int size, int pivot)
|
|
{
|
|
int nbr;
|
|
|
|
nbr = 0;
|
|
while (size-- > 0)
|
|
{
|
|
if (list->n < pivot)
|
|
nbr++;
|
|
list = list->next;
|
|
}
|
|
return (nbr);
|
|
}
|
|
|
|
// pivot is the smallest of the bigger group
|
|
int find_pivot(t_stack *list, int size)
|
|
{
|
|
int pivot;
|
|
t_stack *head;
|
|
|
|
pivot = list->n;
|
|
head = list;
|
|
while (head->next && nbr_element_smaller(list, size, pivot) != size / 2)
|
|
{
|
|
head = head->next;
|
|
pivot = head->n;
|
|
}
|
|
return (pivot);
|
|
}
|
|
|
|
int divide_a(t_stack **a, t_stack **b, t_list *solution)
|
|
{
|
|
int list_size;
|
|
int pivot;
|
|
t_stack *first_rotate;
|
|
|
|
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);
|
|
}
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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");
|
|
}
|
|
|
|
/*
|
|
int find_smallest(t_stack *list, int size)
|
|
{
|
|
t_stack *head;
|
|
int smallest;
|
|
int position;
|
|
|
|
smallest = list->n;
|
|
head = list;
|
|
while (--size > 0)
|
|
{
|
|
head = head->next;
|
|
if (head->n < smallest)
|
|
smallest = head->n;
|
|
}
|
|
position = 0;
|
|
while (list->n != smallest)
|
|
{
|
|
position++;
|
|
list = list->next;
|
|
}
|
|
return (position);
|
|
}
|
|
|
|
void mini_sort(t_stack **a, t_stack **b, t_list *solution)
|
|
{
|
|
int list_size;
|
|
int next;
|
|
int temp;
|
|
|
|
list_size = sublist_size(*a);
|
|
if(list_size == 1)
|
|
return ;
|
|
(*a)->limit = 0;
|
|
while (--list_size > 0)
|
|
{
|
|
next = find_smallest(*a, list_size + 1);
|
|
temp = next;
|
|
while (next-- > 0)
|
|
ra(a, &solution);
|
|
pb(b, a, &solution);
|
|
while (temp-- > 0)
|
|
rra(a, &solution);
|
|
}
|
|
list_size = sublist_size(*b);
|
|
while (list_size-- > 0)
|
|
pa(a, b, &solution);
|
|
(*a)->limit = 1;
|
|
mark_step(solution, "mini_sort");
|
|
}
|
|
*/
|
|
|
|
void mark_sublist(t_stack *list)
|
|
{
|
|
while (list && list->limit != 1)
|
|
{
|
|
if (list->limit == 2)
|
|
list->limit = 0;
|
|
else if (list->limit == 0)
|
|
list->limit = 2;
|
|
list = list->next;
|
|
}
|
|
}
|
|
|
|
int find_smallest(t_stack *list)
|
|
{
|
|
int i;
|
|
int smallest;
|
|
int position;
|
|
|
|
smallest = list->n;
|
|
position = 1;
|
|
i = 0;
|
|
while (list)
|
|
{
|
|
i++;
|
|
if (list->limit == 2 && list->n < smallest)
|
|
{
|
|
smallest = list->n;
|
|
position = i;
|
|
}
|
|
list = list->next;
|
|
}
|
|
if (i - position + 1 < position)
|
|
position = position - i - 1;
|
|
return (position);
|
|
}
|
|
|
|
void sort_big(t_stack **a, t_stack **b, t_list *solution)
|
|
{
|
|
int list_size;
|
|
int next;
|
|
int i;
|
|
|
|
list_size = sublist_size(*a);
|
|
mark_sublist(*a);
|
|
while (--list_size >= 0)
|
|
{
|
|
i = 0;
|
|
next = find_smallest(*a);
|
|
if (next > 0)
|
|
while (++i < next)
|
|
ra(a, &solution);
|
|
else if (next < 0)
|
|
while (i-- > next)
|
|
rra(a, &solution);
|
|
pb(b, a, &solution);
|
|
}
|
|
list_size = sublist_size(*b);
|
|
while (list_size-- > 0)
|
|
pa(a, b, &solution);
|
|
mark_sublist(*a);
|
|
}
|
|
|
|
int find_rank(t_stack *list, int nbr, int i)
|
|
{
|
|
t_stack *head;
|
|
int comp;
|
|
int rank;
|
|
int j;
|
|
|
|
head = list;
|
|
j = 0;
|
|
while (++j <= nbr - i)
|
|
head = head->next;
|
|
comp = head->n;
|
|
head = list;
|
|
j = 0;
|
|
rank = 1;
|
|
while (++j <= nbr)
|
|
{
|
|
if (comp > head->n)
|
|
rank++;
|
|
head = head->next;
|
|
}
|
|
return (rank);
|
|
}
|
|
|
|
int order_is(t_stack *list, int nbr)
|
|
{
|
|
int order;
|
|
int rank;
|
|
int i;
|
|
|
|
i = 0;
|
|
order = 0;
|
|
while (++i <= nbr)
|
|
{
|
|
rank = find_rank(list, nbr, i);
|
|
order = order * 10 + rank;
|
|
}
|
|
return (order);
|
|
}
|
|
|
|
void sort_4(t_stack **a, t_list *solution)
|
|
{
|
|
int order;
|
|
|
|
order = order_is(*a, 4);
|
|
if (order == 1234)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 1243)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 1324)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 1342)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 1423)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 1432)
|
|
{
|
|
ra(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 2134)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 2143)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 2314)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 2341)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 2413)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 2431)
|
|
{
|
|
ra(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 3124)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 3142)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 3214)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 3241)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 3412)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 3421)
|
|
{
|
|
ra(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 4123)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 4132)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 4213)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 4231)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 4312)
|
|
sa(a, &solution);
|
|
}
|
|
|
|
void sort_3(t_stack **a, t_list *solution)
|
|
{
|
|
int order;
|
|
|
|
order = order_is(*a, 3);
|
|
if (order == 123)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 132)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
sa(a, &solution);
|
|
}
|
|
else if (order == 213)
|
|
{
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 231)
|
|
{
|
|
ra(a, &solution);
|
|
sa(a, &solution);
|
|
rra(a, &solution);
|
|
}
|
|
else if (order == 312)
|
|
sa(a, &solution);
|
|
}
|
|
|
|
void sort_2(t_stack **a, t_list *solution)
|
|
{
|
|
int order;
|
|
|
|
order = order_is(*a, 2);
|
|
if (order == 12)
|
|
sa(a, &solution);
|
|
}
|
|
void mini_sort(t_stack **a, t_list *solution)
|
|
{
|
|
int list_size;
|
|
|
|
list_size = sublist_size(*a);
|
|
if(list_size == 1)
|
|
return ;
|
|
(*a)->limit = 0;
|
|
if(list_size == 2)
|
|
sort_2(a, solution);
|
|
else if(list_size == 3)
|
|
sort_3(a, solution);
|
|
else if(list_size == 4)
|
|
sort_4(a, solution);
|
|
/*
|
|
else if(list_size == 5)
|
|
sort_5(a, solution);
|
|
else if(list_size == 6)
|
|
sort_6(a, solution);
|
|
else
|
|
sort_big(a, b, solution);
|
|
*/
|
|
(*a)->limit = 1;
|
|
mark_step(solution, "mini_sort");
|
|
}
|
|
|
|
void hugo_sort(t_stack **a, t_stack **b, t_list *solution)
|
|
{
|
|
if (sublist_size(*a) > 3)
|
|
divide_a(a, b, solution);
|
|
else
|
|
{
|
|
mini_sort(a, solution);
|
|
if (sublist_size(*b) > 3)
|
|
divide_b(a, b, solution);
|
|
else if (sublist_size(*b) > 0)
|
|
send_sublist_to_a(a, b, solution);
|
|
else
|
|
return ;
|
|
}
|
|
hugo_sort(a, b, solution);
|
|
}
|
|
|
|
// /*
|
|
// ** n is the nbr of elements of the list that are competiting
|
|
// ** position start at 0, ie position 3 is the 4th element
|
|
// */
|
|
// int match(t_stack *a, int n, int *smaller)
|
|
// {
|
|
// int position;
|
|
// int i;
|
|
//
|
|
// *smaller = a->n;
|
|
// position = 0;
|
|
// i = 1;
|
|
// while (a->next && i < n)
|
|
// {
|
|
// a = a->next;
|
|
// if (a->n < *smaller)
|
|
// {
|
|
// *smaller = a->n;
|
|
// position = i;
|
|
// }
|
|
// i++;
|
|
// }
|
|
// return (position);
|
|
// }
|
|
//
|
|
// void nb_to_top(t_stack **a, t_list *solution, int i)
|
|
// {
|
|
// int n;
|
|
//
|
|
// if (!i)
|
|
// return ;
|
|
// n = i;
|
|
// while (--n)
|
|
// ra(a, &solution);
|
|
// n = i;
|
|
// sa(a, &solution);
|
|
// while (--n)
|
|
// {
|
|
// rra(a, &solution);
|
|
// sa(a, &solution);
|
|
// }
|
|
// }
|
|
//
|
|
// void push_to_b(t_stack **a, t_stack **b, t_list *solution, int position)
|
|
// {
|
|
// int i;
|
|
//
|
|
// i = position;
|
|
// while (i--)
|
|
// ra(a, &solution);
|
|
// pb(b, a, &solution);
|
|
// while (++i < position)
|
|
// rra(a, &solution);
|
|
// }
|
|
//
|
|
// /*
|
|
// ** so far it's bullshit :p
|
|
// */
|
|
// void hugo_sort(t_stack **a, t_stack **b, t_list *solution)
|
|
// {
|
|
// int last;
|
|
// int position;
|
|
// int value;
|
|
//
|
|
// last = last_element(*a);
|
|
// while ((*a)->n != last)
|
|
// {
|
|
// position = match(*a, 4, &value);
|
|
// if (!(*b) || value > (*b)->n)
|
|
// push_to_b(a, b, solution, position);
|
|
// else
|
|
// ra(a, &solution);
|
|
// }
|
|
// }
|
|
/*
|
|
sa(a, &solution);
|
|
ra(a, &solution);
|
|
rra(a, &solution);
|
|
|
|
pb(b, a, &solution);
|
|
pa(a, b, &solution);
|
|
|
|
sb(b, &solution);
|
|
rb(b, &solution);
|
|
rrb(b, &solution);
|
|
|
|
rrr(a, b, &solution);
|
|
rr(a, b, &solution);
|
|
*/
|