push_swap/srcs/push_swap.c

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   push_swap.c                                        :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2019/03/03 11:41:49 by tmaze             #+#    #+#             */
/*   Updated: 2019/03/10 15:17:33 by tmaze            ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "push_swap.h"

void	mark_groups(t_psdata *data)
{
	t_stack	*ptr;
	int		inds;

	ptr = data->a;
	inds = 1;
	while (ptr)
	{
		ptr->ind = inds;
		if (ptr->next && ptr->nb > ptr->next->nb)
			inds++;
		ptr = ptr->next;
	}
}

void	get_min_max(t_psdata *data, int *min_max, int *ind_min_max)
{
	t_stack *ptr;
	int		i;

	min_max[0] = FT_INT_MAX;
	min_max[1] = FT_INT_MIN;
	ptr = data->a;
	i = 0;
	while (ptr)
	{
		if (ptr->nb < min_max[0] && (ind_min_max[0] = i) == i)
			min_max[0] = ptr->nb;
		if (ptr->nb > min_max[1] && (ind_min_max[1] = i) == i)
			min_max[1] = ptr->nb;
		i++;
		ptr = ptr->next;
	}
}

void	sortfor3(t_psdata *data)
{
	int		min_max[2];
	int		ind_min_max[2];

	get_min_max(data, min_max, ind_min_max);
	while (ind_min_max[0] != 0 || ind_min_max[1] != 2)
	{
		if (ind_min_max[0] == ind_min_max[1] - 1)
			ft_printf("sa\n");
		if (ind_min_max[0] == ind_min_max[1] - 1)
			ps_swap(data, 'a');
		if (ind_min_max[1] == 0)
			ft_printf("ra\n");
		if (ind_min_max[1] == 0)
			ps_rot(data, 'a');
		if (ind_min_max[0] == 2 && ind_min_max[1] == 1)
			ft_printf("rra\n");
		if (ind_min_max[0] == 2 && ind_min_max[1] == 1)
			ps_rerot(data, 'a');
		get_min_max(data, min_max, ind_min_max);
	}
}

void	sortfor5(t_psdata *data)
{
	ft_printf("pb\n");
	ps_push(data, 'b');
	ft_printf("pb\n");
	ps_push(data, 'b');
	if (data->b->nb > data->b->next->nb)
		ft_printf("sb\n");
	if (data->b->nb > data->b->next->nb)
		ps_swap(data, 'b');
	sortfor3(data);
	data->b->ind = 1;
	data->b->next->ind = 1;
	data->a->ind = 2;
	data->a->next->ind = 2;
	data->a->next->next->ind = 2;
	while (data->a->ind == 2 || data->size_b > 0)
	{
		if (data->a->ind != 2
			|| (data->size_b > 0 && data->b->nb < data->a->nb))
			ft_printf("pa\n");
		if (data->a->ind != 2
			|| (data->size_b > 0 && data->b->nb < data->a->nb))
			ps_push(data, 'a');
		data->a->ind = 3;
		ft_printf("ra\n");
		ps_rot(data, 'a');
	}
}

t_stack	*get_last_a(t_psdata *data)
{
	t_stack	*ptr;

	ptr = data->a;
	while (ptr && ptr->next)
		ptr = ptr->next;
	return (ptr);
}

int		sort2(t_psdata *data)
{
	t_list	*tmp;
	t_stack	*last;
	int		inds;
	int		inds2;

	last = get_last_a(data);
	inds = last->ind + 1;
	while (data->a->ind != last->ind)
	{
		inds2 = data->a->ind;
		while (data->a->ind == inds2 && (tmp = add_op(data, "pb\0")) != NULL)
			ps_push(data, 'b');
		if (tmp == NULL)
			return (0);
		inds2 = last->ind;
		while (last->ind == inds2 || data->size_b > 0)
		{
			if ((last->ind != inds2 && data->size_b > 0) || (data->b && data->b->nb > last->nb))
			{
				if (add_op(data, "pa\0") == NULL)
					return (0);
				ps_push(data, 'a');
				data->a->ind = inds;
			}
			else if (data->size_b == 0 || data->b->nb < last->nb)
			{
				if (add_op(data, "rra") == NULL)
					return (0);
				ps_rerot(data, 'a');
				data->a->ind = inds;
				last = get_last_a(data);
			}
		}
		inds++;
	}
	return (1);
}

void	sort(t_psdata *data)
{
	t_stack	*ptr;
	int		inds;
	int		inds2;
	int		i;

	ptr = data->a;
	while (ptr && ptr->next)
		ptr = ptr->next;
	inds2 = ptr->ind + 1;
	while (data->a->ind != ptr->ind)
	{
		inds = data->a->ind;
		while (data->a->ind == inds)
		{
			ft_printf("pb\n");
			ps_push(data, 'b');
			if (data->size_b == 2)
				ft_printf("sb\n");
			if (data->size_b == 2)
				ps_swap(data, 'b');
			else if (data->size_b > 2)
				ft_printf("rb\n");
			if (data->size_b > 2)
				ps_rot(data, 'b');
		}
		inds = data->a->ind;
		if (data->size_a == 3)
		{
			sortfor3(data);
			data->a->ind = inds;
			data->a->next->ind = inds;
			data->a->next->next->ind = inds;
		}
		while (inds == data->a->ind || data->size_b > 0)
		{
			if (data->a->ind != inds || (data->size_b > 0 && data->b->nb < data->a->nb))
			{
				ft_printf("pa\n");
				ps_push(data, 'a');
			}
			data->a->ind = inds2;
			ft_printf("ra\n");
			ps_rot(data, 'a');
		}
		i = 0;
		ptr = data->a;
		while (ptr)
		{
			ptr = ptr->next;
			i++;
		}
		ptr = data->a;
		while (ptr && ptr->next)
			ptr = ptr->next;
		inds2 = ptr->ind + 1;
	}
}

void	clean_op(t_psdata *data)
{
	t_list	*it;
	t_list	**prec;
	char	*ct1;
	char	*ct2;

	it = data->op;
	prec = &(data->op);
	while (it && it->next)
	{
		ct1 = (char*)(it->content);
		ct2 = (char*)(it->next->content);
		if (ct1 && ct2 && ct1[0] == 'p' && ct2[0] == 'p' && ct1[1] != ct2[1])
		{
			*prec = it->next->next;
			ft_memdel(&(it->next->content));
			ft_memdel((void**)(&(it->next)));
			ft_memdel(&(it->content));
			ft_memdel((void**)(&it));
			it = data->op;
			prec = &(data->op);
		}
		else
		{
			prec = &(it->next);
			it = it->next;
		}
	}
}

int		main(int ac, char **av)
{
	t_list		*it;
	t_stack		*ptr;
	t_psdata	data;

	ps_initdata(&data);
	if (!get_params(&data, ac, av))
		return (0);
	ptr = data.a;
	if (ptr == NULL)
		ft_putendl("Empty");
	while (ptr)
	{
		ptr->ind = 0;
		ptr = ptr->next;
	}
	if (data.size_a == 3)
	{
		sortfor3(&data);
		ps_stkclean(&data);
		return (0);
	}
	else if (data.size_a == 5)
	{
		sortfor5(&data);
		ps_stkclean(&data);
		return (0);
	}
	mark_groups(&data);
	if (sort2(&data) == 0)
		ft_putendl_fd("Error\n", 2);
//	sort(&data);
	else
	{
		clean_op(&data);
		it = data.op;
		while (it)
		{
			ft_printf("%s\n", (char*)(it->content));
			it = it->next;
		}
	}
	ps_stkclean(&data);
	return (0);
}