////////////////////////////////
/// Fonctions de test: piles ///
////////////////////////////////

#ifndef STACKTEST_H_
#define STACKTEST_H_

#include "stack.h"

// Crée une pile aléatoire de valeurs entre 0 et maxval de taille size.
// Si size est inférieure ou égal à 0, la pile construite est vide.
stack *random_stack(int size, int maxval);

// Crée la pile suivante:
//   1
//   2
//   .
//   .
//   .
//  n-2
//  n-1
//    n
//*****
//
// Si n est inférieur ou égal à 0, la pile construite est vide.
stack *tower_stack(int n);

// Crée une copie de la pile prise en entrée.
// Cette dernière doit rester inchangée après appel de la fonction.
stack *copy_stack(stack *p);

// Trie la pile par ordre croissant (la plus grande valeur au sommet).
// L'algorithme devra être basé sur le principe du tri à bulles.
// Une seule structure auxiliaire est autorisée: une seconde pile.
// Toute autre structure auxiliaire (comme un tableau) est interdite.
void bubble_sort_stack(stack *p);

// Tours de Hanoi.
//
// Si n > 0, affiche la séquence de mouvements qui résout le problème des tours
// de Hanoi pour n disques. On utilisera la primitive qui sert à afficher une ou
// plusieurs piles.
//
// Par exemple, pour $n = 3$, la fonction dont afficher les informations
// suivantes: Situation initiale:
//     1
//     2
//     3
// *****     *****     *****
//
// Étape 1:
//
//     2
//     3                   1
// *****     *****     *****
//
// Étape 2:
//
//
//     3         2         1
// *****     *****     *****
//
// Étape 3:
//
//               1
//     3         2
// *****     *****     *****
//
// Étape 4:
//
//               1
//               2         3
// *****     *****     *****
//
// Étape 5:
//
//
//     1         2         3
// *****     *****     *****
//
// Étape 6:
//
//                         2
//     1                   3
// *****     *****     *****
//
// Étape 7:
//                         1
//                         2
//                         3
// *****     *****     *****
void hanoi(int n);

// Fonction récursive auxiliaire pour les tours de Hanoi.
// p1, p2, p3 sont les trois piles de départ.
// q1, q2, q3 mémorisent les trois piles de départ et ne changent pas au cours
// des appels. Utilisées pour l'affichage (on affiche q1, puis q2, puis q3).
// n est le nombre de disques à déplacer.
// max est l'espacement horizontal que prend l'affichage (utilisez max=n).
// *count permet de compter les étapes réalisées.
void hanoi_rec(stack *p1, stack *p2, stack *p3, stack *q1, stack *q2, stack *q3,
               int n, int max, int *count);

#endif // STACKTEST_H_