init projet

tp3/TP3/stacktest.h

@@ -0,0 +1,104 @@
+////////////////////////////////
+/// 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_