42_adjoly/push_swap
Archived
1
0
Fork 0
Code

asdflkaj

Browse Source
This commit is contained in:
Adam Joly
2024-02-12 15:27:29 +01:00
commit 220751604a
16 changed files with 866 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
Makefile Normal file
View File

@ -0,0 +1,56 @@
# **************************************************************************** #
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2023/11/01 11:03:22 by adjoly #+# #+# #
# Updated: 2024/02/08 18:39:49 by adjoly ### ########.fr #
# #
# **************************************************************************** #
NAME = push_swap
CC = cc
SRCS = main.c \
parsing.c \
stack/ft_stackadd_back.c \
stack/ft_stackadd_front.c \
stack/ft_stackdelone.c \
stack/ft_stackclear.c \
stack/ft_stacknew.c \
stack/ft_stacklast.c \
stack/ft_stacksize.c \
operations/ft_swapstack.c \
operations/ft_pushstack.c \
OBJS = $(SRCS:.c=.o)
FLAGS = -Werror -Wall -Wextra -g
HEADERS = so_long.h
LIB = libft/libft.a \
$(NAME): $(OBJS)
make -C libft
$(CC) $(FLAGS) $(OBJS) $(LIB) -o $(NAME)
%.o: %.c
$(CC) $(FLAGS) -I $(HEADERS) $< -c -o $@
all: $(NAME)
clean:
make -C libft clean
rm -f $(OBJS)
fclean: clean
make -C libft fclean
rm -f $(NAME)
re: fclean all
.PHONY: clean all re fclean

1
libft Submodule

Submodule libft added at 6af3df4973

48
main.c Normal file
View File

@ -0,0 +1,48 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/04 12:14:22 by adjoly #+# #+# */
/* Updated: 2024/02/12 14:18:37 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int main(int ac, char **av)
{
t_stack *stack;
t_stack *tmp;
t_stack *stack_b;
stack = ft_parsing(ac, av);
tmp = stack;
stack_b = NULL;
while (tmp)
{
ft_printf("%d\n", tmp->nb);
tmp = tmp->next;
}
ft_push_b(&stack, &stack_b);
ft_swap_a(stack);
tmp = stack;
while (tmp)
{
ft_printf("%d\n", tmp->nb);
tmp = tmp->next;
}
ft_printf("stackb\n");
tmp = stack_b;
while (tmp)
{
ft_printf("%d\n", tmp->nb);
tmp = tmp->next;
}
ft_stackclear(&stack);
ft_stackclear(&stack_b);
return (0);
}

36
operations/ft_pushstack.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_pushstack.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/08 18:08:51 by adjoly #+# #+# */
/* Updated: 2024/02/09 15:48:39 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
void ft_push_a(t_stack **stack_a, t_stack **stack_b)
{
t_stack *tmp_a;
ft_putendl_fd("pb", 1);
tmp_a = *stack_b;
*stack_b = (*stack_b)->next;
tmp_a->next = *stack_a;
*stack_a = tmp_a;
}
void ft_push_b(t_stack **stack_a, t_stack **stack_b)
{
t_stack *tmp_b;
ft_putendl_fd("pb", 1);
tmp_b = *stack_a;
*stack_a = (*stack_a)->next;
tmp_b->next = *stack_b;
*stack_b = tmp_b;
}

41
operations/ft_swapstack.c Normal file
View File

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_swapstack.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/08 17:55:21 by adjoly #+# #+# */
/* Updated: 2024/02/08 18:10:02 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
void ft_swapstack(t_stack *stack)
{
int tmp;
tmp = stack->nb;
stack->nb = stack->next->nb;
stack->next->nb = tmp;
}
void ft_swap_a(t_stack *stack_a)
{
ft_putendl_fd("sa", 1);
ft_swapstack(stack_a);
}
void ft_swap_b(t_stack *stack_b)
{
ft_putendl_fd("sb", 1);
ft_swapstack(stack_b);
}
void ft_stack_ss(t_stack *stack_a, t_stack *stack_b)
{
ft_putendl_fd("ss", 1);
ft_swapstack(stack_a);
ft_swapstack(stack_b);
}

51
parsing.c Normal file
View File

@ -0,0 +1,51 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parsing.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/04 12:05:43 by adjoly #+# #+# */
/* Updated: 2024/02/08 17:41:41 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
void ft_freearr(char **arr)
{
size_t i;
i = 0;
while (arr[i])
{
free(arr[i]);
i++;
}
free(arr);
}
t_stack *ft_parsing(int ac, char **av)
{
t_stack *parsed_data;
char **tmp_split;
size_t i;
i = 0;
(void)ac;
av++;
parsed_data = NULL;
while (*av)
{
i = 0;
tmp_split = ft_split(*av, ' ');
while (tmp_split[i])
{
ft_stackadd_back(&parsed_data, ft_stacknew(ft_atoi(tmp_split[i])));
i++;
}
ft_freearr(tmp_split);
av++;
}
return (parsed_data);
}

40
push_swap.h Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* push_swap.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/04 12:18:29 by adjoly #+# #+# */
/* Updated: 2024/02/09 15:49:14 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PUSH_SWAP_H
# define PUSH_SWAP_H
typedef struct s_stack
{
int nb;
struct s_stack *next;
} t_stack;
#include "libft/libft.h"
t_stack *ft_parsing(int ac, char **av);
void ft_stackadd_back(t_stack **stack, t_stack *new);
void ft_stackadd_front(t_stack **stack, t_stack *new);
void ft_stackclear(t_stack **stack);
void ft_stackdelone(t_stack *stack);
t_stack *ft_stacklast(t_stack *stack);
t_stack *ft_stacknew(int content);
size_t ft_stacksize(t_stack *stack);
void ft_swap_a(t_stack *stack_a);
void ft_swap_b(t_stack *stack_b);
void ft_stack_ss(t_stack *stack_a, t_stack *stack_b);
void ft_push_a(t_stack **stack_a, t_stack **stack_b);
void ft_push_b(t_stack **stack_a, t_stack **stack_b);
#endif

178
push_swap_tuto.c Normal file
View File

@ -0,0 +1,178 @@
#include <stdio.h>
#include <stdlib.h>
typedef struct s_stack
{
int nb_init;
int nb;
struct s_stack *next;
} t_stack;
t_stack *ft_stacknew(int content)
{
/* creer avec malloc(), un maillon avec comme nb_init -> content*/
t_stack *new;
new = malloc(sizeof(t_stack));
return (NULL);
}
int ft_stacksize(t_stack *stack)
{
/*donne la taille d'une t_stack*/
return (0);
}
void ft_stackadd_back(t_stack **stack, t_stack *new)
{
/* ajoute a la fin de stack -> new*/
return ;
}
t_stack *ft_stacklast(t_stack *stack)
{
/* renvoie le dernier maillon*/
return (NULL);
}
void ft_stackadd_front(t_stack **stack, t_stack *new)
{
/* ajoute au debut de stack -> new*/
return ;
}
int ft_verif_nb(char const *str)
{
/*verifie que un str est un nombre valable,
qu'il passe dans atoi,
et qu'il ne depasse pas les limites des int*/
/*renvoie un booléen si le nb est
valide(1)
invalide (0)*/
return (0);
}
t_stack *fill_struct(int ac, char **av)
{
/*remplie la structure avec les élements de av
-> il faut split chaque av
"3 2" "1 10" "5" -> 3 2 1 10 5
et verifier que chaque nb passe dans atoi
puis utiliser atoi pour remplir la structure choisit
si un nb est invalide, ne pas oublier de free, et renvoyer NULL*/
}
int verif_double(t_stack *stack)
{
/*verifie si la liste ne contient aucun doublons*/
/*renvoie un booléen si la liste est
bonne (aucun doublons) -> (1)
pas bonne (1 ou plusieurs doublons) -> (0)*/
return (0);
}
//j'espere que le debut étais pas trop dur car voici un premier gros defi
// tu dois "lisser" toutes les valeur, a partir de 0, et il n'y aura pas d'ecart superieur a 1
// pour ca tu va assiger a chaque maillon->nb une valeur
// qui depend de toute les nb_init de la list
// 0 1000 2 2000 -> 0 2 1 3
// -4 1 9 5 2 8 4 -> 0 1 6 4 2 5 3
// une vision simple de le voir/le coder:
//compter combien d'element dans toute la liste possede un nb_init en dessous du nb_init conserner
void replace_nb_init(t_stack *stack)
{
/*assigne pour chaque maillon, un nb,
ce nb est la possition finale dans la liste trier qu'il aura*/
}
// mtn que tu a modifier tous et simplifier les nb_init dans nb
// a partir de mtn tu ne touche plus du tout a nb_init,
// uniquement a nb
int is_sorted(t_stack *stack_a)
{
/*verifie si la liste est trier*/
/*renvoie un booléen si la liste est
trier(1)
pas trier(0)*/
return (0);
}
// il va falloir attendre la v2 pour les tests des fonctions a partir de mtn
//, et pour les explications plus soffistiquer de la sutie:)
// mais tu peux quand meme les faire sans aide ? :)
void sa(t_stack *stack_a)
{
/*echange les 2 elements en haut de la pile
print "sa"*/
}
void sb(t_stack *stack_b)
{
/*echange les 2 elements en haut de la pile
print "sb"*/
}
void ss(t_stack *stack_a, t_stack *stack_b)
{
/*effectue sa et sb
print "ss"*/
}
void pa(t_stack *stack_a, t_stack *stack_b)
{
/*envoie l'element en haut de la pile b -> en haut de la pile a
print "pa"*/
}
void pb(t_stack *stack_a, t_stack *stack_b)
{
/*envoie l'element en haut de la pile a -> en haut de la pile b
print "pb"*/
}
void ra(t_stack *stack_a)
{
/*envoie l'element en haut de la pile a -> en bas de la pile a
print "ra"*/
}
void rb(t_stack *stack_b)
{
/*envoie l'element en haut de la pile b -> en bas de la pile b
print "rb"*/
}
void rr(t_stack *stack_a, t_stack *stack_b)
{
/*effectue ra et rb
print "rr"*/
}
void rra(t_stack *stack_a)
{
/*envoie l'element en bas de la pile a -> en haut de la pile a
print "rra"*/
}
void rrb(t_stack *stack_b)
{
/*envoie l'element en bas de la pile b -> en haut de la pile b
print "rrb"*/
}
void rrr(t_stack *stack_a, t_stack *stack_b)
{
/*effectue rra et rrb
print "rrr"*/
}

26
stack/ft_stackadd_back.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stackadd_back.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/05 11:40:39 by adjoly #+# #+# */
/* Updated: 2024/02/05 11:42:15 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
void ft_stackadd_back(t_stack **stack, t_stack *new)
{
if (!stack)
return ;
if (!*stack)
{
(*stack) = new;
return ;
}
ft_stacklast(*stack)->next = new;
}

24
stack/ft_stackadd_front.c Normal file
View File

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stackadd_front.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/04 18:52:38 by adjoly #+# #+# */
/* Updated: 2024/02/05 11:38:54 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
void ft_stackadd_front(t_stack **stack, t_stack *new)
{
if (!stack)
return ;
if (!new)
return ;
new->next = *stack;
*stack = new;
}

27
stack/ft_stackclear.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stackclear.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/04 18:54:56 by adjoly #+# #+# */
/* Updated: 2024/02/05 11:39:22 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
void ft_stackclear(t_stack **stack)
{
t_stack *tmp;
tmp = NULL;
while (stack && *stack)
{
tmp = (*stack)->next;
ft_stackdelone(*stack);
*stack = tmp;
}
}

21
stack/ft_stackdelone.c Normal file
View File

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stackdelone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/06 10:27:14 by adjoly #+# #+# */
/* Updated: 2024/02/06 10:28:24 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
void ft_stackdelone(t_stack *stack)
{
if (stack == NULL)
return ;
free(stack);
}

27
stack/ft_stacklast.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stacklast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/06 10:18:01 by adjoly #+# #+# */
/* Updated: 2024/02/08 16:24:36 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
t_stack *ft_stacklast(t_stack *stack)
{
t_stack *tmp;
if (!stack)
return (NULL);
tmp = stack;
while (tmp->next)
tmp = tmp->next;
return (tmp);
}

26
stack/ft_stacknew.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stacknew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/05 11:45:19 by adjoly #+# #+# */
/* Updated: 2024/02/05 14:11:46 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
t_stack *ft_stacknew(int nb)
{
t_stack *stack;
stack = malloc(sizeof(t_stack));
if (!stack)
return (NULL);
stack->nb = nb;
stack->next = NULL;
return (stack);
}

27
stack/ft_stacksize.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_stacksize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <adjoly@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/02/05 11:42:40 by adjoly #+# #+# */
/* Updated: 2024/02/05 11:44:21 by adjoly ### ########.fr */
/* */
/* ************************************************************************** */
#include "../push_swap.h"
size_t ft_stacksize(t_stack *stack)
{
size_t i;
i = 0;
while (stack)
{
stack = stack->next;
i++;
}
return (i);
}

237
verif/verif_all.c Normal file
View File

@ -0,0 +1,237 @@
#include <stdio.h>
#include <stdlib.h>
void afficher_KO_OK(int i)
{
if (i == 1)
printf("ok ");
else
printf("ERREUR ");
}
/* si tu modif un prototype de fonction: modif la aussi*/
typedef struct s_stack
{
int nb_init;
int nb;
struct s_stack *next;
} t_stack;
t_stack *ft_stacknew(int content);
int ft_stacksize(t_stack *stack);
void ft_stackadd_back(t_stack **stack, t_stack *new);
t_stack *ft_stacklast(t_stack *stack);
void ft_stackadd_front(t_stack **stack, t_stack *new);
int ft_verif_nb(char const *str);
t_stack *fill_struct(int ac, char **av);
int verif_double(t_stack *stack);
void replace_nb_init(t_stack *stack);
int is_sorted(t_stack *stack_a);
void main_stacknew()
{
printf("stacknew: ");
t_stack *new = ft_stacknew(1000);
afficher_KO_OK(new->nb_init == 1000);
afficher_KO_OK(new->next == NULL);
printf("\n");
}
void main_stacksize()
{
printf("stacksize: ");
t_stack *new = ft_stacknew(1000);
afficher_KO_OK(ft_stacksize(new) == 1);
t_stack *new2 = ft_stacknew(1);
new->next = new2;
afficher_KO_OK(ft_stacksize(new) == 2);
afficher_KO_OK(ft_stacksize(NULL) == 0);
printf("\n");
}
void main_stackadd_back()
{
printf("stackadd_back: ");
t_stack *new = ft_stacknew(1000);
t_stack *new2 = ft_stacknew(1);
t_stack *new3 = ft_stacknew(2);
ft_stackadd_back(&new, new2);
ft_stackadd_back(&new, new3);
afficher_KO_OK(ft_stacksize(new) == 3);
afficher_KO_OK(new->nb_init == 1000);
afficher_KO_OK(new->next->nb_init == 1);
afficher_KO_OK(new->next->next->nb_init == 2);
printf("\n");
}
void main_stacklast()
{
printf("stacklast: ");
t_stack *new = ft_stacknew(1000);
t_stack *new2 = ft_stacknew(1);
t_stack *new3 = ft_stacknew(2);
new2->next = new3;
new->next = new2;
afficher_KO_OK(ft_stacklast(new)->nb_init == 2);
afficher_KO_OK(ft_stacklast(new)->next == NULL);
t_stack *new4 = ft_stacknew(6);
new3->next = new4;
afficher_KO_OK(ft_stacklast(new)->nb_init == 6);
afficher_KO_OK(ft_stacklast(new)->next == NULL);
afficher_KO_OK(ft_stacklast(new2)->nb_init == 6);
afficher_KO_OK(ft_stacklast(new2)->next == NULL);
printf("\n");
}
void main_stackadd_front()
{
printf("stackadd_front: ");
t_stack *new = ft_stacknew(1000);
t_stack *new2 = ft_stacknew(1);
t_stack *new3 = ft_stacknew(2);
ft_stackadd_front(&new, new2);
ft_stackadd_front(&new, new3);
afficher_KO_OK(ft_stacksize(new) == 3);
afficher_KO_OK(new->nb_init == 2);
afficher_KO_OK(new->next->nb_init == 1);
afficher_KO_OK(new->next->next->nb_init == 1000);
printf("\n");
}
void main_stack()
{
main_stacknew();
main_stacksize();
main_stackadd_back();
main_stacklast();
main_stackadd_front();
}
void main_verif_nb()
{
printf("verif_nb: ");
afficher_KO_OK(ft_verif_nb("0") == 1);
afficher_KO_OK(ft_verif_nb("1000") == 1);
afficher_KO_OK(ft_verif_nb("-1000") == 1);
afficher_KO_OK(ft_verif_nb("2147483647") == 1);
afficher_KO_OK(ft_verif_nb("2147483648") == 0);
afficher_KO_OK(ft_verif_nb("-2147483648") == 1);
afficher_KO_OK(ft_verif_nb("-2147483649") == 0);
afficher_KO_OK(ft_verif_nb("1234567890123456") == 0);
printf("\n");
}
void main_fill_struct()
{
int ac = 4;
char **av = (char *[]){"1 2 3", "4 5 6","7 8 9" "10"};
t_stack *stack = fill_struct(ac, av);
afficher_KO_OK(ft_stacksize(stack) == 10);
afficher_KO_OK(stack->nb_init == 1 &&
stack->next->nb_init == 2 &&
stack->next->next->nb_init == 3 &&
stack->next->next->next->nb_init == 4 &&
stack->next->next->next->next->next->nb_init == 5 &&
stack->next->next->next->next->next->next->nb_init == 6 &&
ft_stacklast(stack)->nb_init == 10);
ac = 1;
av = (char *[]){"1 2 3 4 5 6 7 8 9 10"};
stack = fill_struct(ac, av);
afficher_KO_OK(ft_stacksize(stack) == 10);
afficher_KO_OK(stack->nb_init == 1 &&
stack->next->nb_init == 2 &&
stack->next->next->nb_init == 3 &&
stack->next->next->next->nb_init == 4 &&
stack->next->next->next->next->next->nb_init == 5 &&
stack->next->next->next->next->next->next->nb_init == 6 &&
ft_stacklast(stack)->nb_init == 10);
ac = 10;
av = (char *[]){"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
stack = fill_struct(ac, av);
afficher_KO_OK(ft_stacksize(stack) == 10);
afficher_KO_OK(stack->nb_init == 1 &&
stack->next->nb_init == 2 &&
stack->next->next->nb_init == 3 &&
stack->next->next->next->nb_init == 4 &&
stack->next->next->next->next->next->nb_init == 5 &&
stack->next->next->next->next->next->next->nb_init == 6 &&
ft_stacklast(stack)->nb_init == 10);
ac = 10;
av = (char *[]){"1", "2", "3", "4", "5", "6", "7", "8", "9", "2147483648"};
stack = fill_struct(ac, av);
afficher_KO_OK(stack == NULL);
}
void main_verif_double()
{
printf("verif_double: ");
t_stack *new = ft_stacknew(0);
t_stack *new2 = ft_stacknew(1);
t_stack *new3 = ft_stacknew(3);
new2->next = new3;
new->next = new2;
afficher_KO_OK(verif_double(new2) == 1);
afficher_KO_OK(verif_double(new) == 1);
t_stack *new4 = ft_stacknew(0);
new3->next = new4;
afficher_KO_OK(is_sorted(new) == 0);
new->nb_init = -1;
afficher_KO_OK(is_sorted(new) == 0);
printf("\n");
}
void main_replace_nb_init()
{
printf("verif_double: ");
t_stack *new = ft_stacknew(1000);
t_stack *new2 = ft_stacknew(1);
t_stack *new3 = ft_stacknew(20000);
new2->next = new3;
new->next = new2;
replace_nb_init(new);
afficher_KO_OK(new->nb == 1 && new->next->nb == 0 && new->next->next->nb == 2);
t_stack *new4 = ft_stacknew(0);
new3->next = new4;
replace_nb_init(new);
afficher_KO_OK(new->nb == 2 && new->next->nb == 1 && new->next->next->nb == 3 && new->next->next->next->nb == 0);
printf("\n");
}
void main_is_sorted()
{
printf("stackis_sorted: ");
t_stack *new = ft_stacknew(1000);
new->nb = 1000;
t_stack *new2 = ft_stacknew(1);
new2->nb = 1;
t_stack *new3 = ft_stacknew(3);
new3->nb = 3;
new2->next = new3;
new->next = new2;
afficher_KO_OK(is_sorted(new2) == 1);
afficher_KO_OK(is_sorted(new) == 0);
t_stack *new4 = ft_stacknew(2);
new4->nb = 2;
new3->next = new4;
new->nb = 0;
afficher_KO_OK(is_sorted(new) == 0);
new4->nb = 6;
afficher_KO_OK(is_sorted(new) == 1);
printf("\n");
}
int main()
{
main_stack();
main_verif_nb();
main_fill_struct();
main_is_sorted();
main_verif_double();
main_replace_nb_init();
}