/// <summary>
/// Permet d'insérer un objet dans une queue à l'emplacement voulu.
/// </summary>
/// <param name="objet">L'objet que l'on souhaite Ajouter dans la queue</param>
/// <param name="numero">L'emplacement dans la queue où l'on souhaite Ajouter l'objet</param>
/// <returns>la queue avec l'objet inséré</returns>
public void Inserer(Coureur objet, int index)
{
Console.WriteLine("\n------ Insertion ------ \n");
Queue <Coureur> res = new Queue <Coureur>();
if (index > _queue.Count)
{
res = _queue;
res.Enqueue(objet);
Console.WriteLine("{0} a été ajouté à la fin de la collection.\n", objet.ToString());
}
else
{
int i = 1;
foreach (Coureur entry in _queue)
{
if (i == index)
{
Console.WriteLine("{0} a été ajouté à l'index {1}.\n", objet.ToString(), i);
res.Enqueue(objet);
i++;
}
res.Enqueue(entry);
i++;
}
}
_queue = res;
}
/// <summary>
/// Fonction récursive qui permet de trier la queue
/// </summary>
/// <param name="rejet"></param>
/// <param name="garde"></param>
/// <param name="nb"></param>
/// <returns></returns>
public Queue <Coureur> TriRecursif(Queue <Coureur> rejet, Queue <Coureur> garde, int nb)
{
Coureur coureurT = rejet.Peek();
rejet.Dequeue();
Queue <Coureur> temp = new Queue <Coureur>(rejet);
rejet.Clear();
do
{
foreach (Coureur entry in temp)
{
if (coureurT.CompareTo(entry) == 1)
{
rejet.Enqueue(coureurT);
coureurT = entry;
}
else if (coureurT.CompareTo(entry) == -1)
{
rejet.Enqueue(entry);
}
}
garde.Enqueue(coureurT);
if (rejet.Count > 0)
{
garde = TriRecursif(rejet, garde, nb);
}
} while (garde.Count < (nb - 1));
return(garde);
}
/// <summary>
/// Permet d'insérer un objet à l'emplacement voulu
/// </summary>
/// <param name="objet">L'objet à insérer</param>
/// <param name="numero">L'emplacementoù on veut insérer l'objet</param>
public void Inserer(Coureur objet, int index)
{
Console.WriteLine("\n------ Insertion ------ \n");
Stack <Coureur> res = new Stack <Coureur>();
if (index > _stack.Count)
{
res.Push(objet);
Console.WriteLine("{0} a été ajouté à la fin de la collection.\n", objet.ToString());
index = -1;
}
else
{
index--;
}
for (int i = _stack.Count - 1; i >= 0; i--)
{
res.Push(_stack.ElementAt(i));
if (i == index)
{
Console.WriteLine("{0} a été ajouté à l'index {1}.\n", objet.ToString(), (index + 1));
res.Push(objet);
}
}
_stack = res;
}
/// <summary>
/// Permet de trier la pile de façon récursif
/// </summary>
/// <param name="rejet">Le stack des objets non triés</param>
/// <param name="garde">Le stack déjà trié</param>
/// <param name="nb">La taille du stack contenant tous les objets</param>
/// <returns>Le stack trié</returns>
public Stack <Coureur> TriRecursif(Stack <Coureur> rejet, Stack <Coureur> garde, int nb)
{
Coureur coureurT = rejet.Peek();
rejet.Pop();
Stack <Coureur> temp = new Stack <Coureur>(rejet);
rejet.Clear();
do
{
foreach (Coureur entry in temp)
{
if (coureurT.CompareTo(entry) == -1)
{
rejet.Push(coureurT);
coureurT = entry;
}
else
if (coureurT.CompareTo(entry) == 1)
{
rejet.Push(entry);
}
}
garde.Push(coureurT);
if (rejet.Count > 0)
{
garde = TriRecursif(rejet, garde, nb);
}
} while (garde.Count < (nb - 1));
return(garde);
}
/// <summary>
/// Permet d'insérer un objet dans une queue à l'emplacement voulu.
/// </summary>
/// <param name="key">La clé du couple clé/valeur que l'on veut insérer</param>
/// <param name="value">La valeur du couple clé/valeur que l'on veut insérer</param>
/// <param name="index">L'endroit de la collection où l'on veut insérer notre objet</param>
public void Inserer(Int32 key, Coureur value, int index)
{
Console.WriteLine("\n------ Insertion ------ \n");
Dictionary <Int32, Coureur> res = new Dictionary <Int32, Coureur>();
if (index > _dictionary.Count)
{
res = _dictionary;
res.Add(key, value);
Console.WriteLine("{0} / {1} a été ajouté à la fin de la collection.\n", key, value);
}
else
{
int i = 1;
foreach (KeyValuePair <Int32, Coureur> entry in _dictionary)
{
if (i == index)
{
Console.WriteLine("{0} / {1} a été ajouté à l'index {1}.\n", key, value, i);
res.Add(key, value);
i++;
}
res.Add(entry.Key, entry.Value);
i++;
}
}
_dictionary = res;
}
/// <summary>
/// Permet d'Ajouter un couple clé/valeur dans la collection
/// </summary>
/// <param name="nom">La chaîne de caractère correspondant à la valeur dans le couple clé/valeur</param>
/// <param name="numero">Le int correspondant à la clé dans le couple clé/valeur</param>
public void Ajouter(Int32 key, Coureur value)
{
Console.WriteLine("\n------ Ajout ------ \n");
try
{
_dictionary.Add(key, value);
Console.WriteLine("Le couple {0} / {1} a bien été ajouté.\n", key, value);
}
catch (ArgumentException)
{
Console.WriteLine("x-x Le numéro a déjà été donné.\n");
}
}
/// <summary>
/// Permet de RechercherKey dans une collection un couple clé/valeur en fonction de la clé
/// </summary>
/// <param name="numero">Le paramètre correspondant à la clé que l'on souhaite retrouver.</param>
public void RechercherKey(int key)
{
Console.WriteLine("\n------ Recherche ------ \n");
Coureur value = new Coureur();
if (_dictionary.TryGetValue(key, out value))
{
Console.WriteLine("Le coureur correspondant au maillot {0} est {1}.\n", key, value);
}
else
{
Console.WriteLine("x-x Il n'y a aucune clé correspondante à {0}.\n", key);
}
}
/// <summary>
/// Permet de RechercherKey un objet en fonction de sa valeur
/// </summary>
/// <param name="objet">L'objet que l'on aimerait retrouver</param>
public void Rechercher(Coureur objet)
{
Console.WriteLine("\n------ Recherche ------ \n");
if (_queue.Contains(objet))
{
for (int i = 0; i < _queue.Count; i++)
{
if (_queue.ElementAt(i).Equals(objet))
{
Console.WriteLine("n°{0} : {1}\n", i, _queue.ElementAt(i));
}
}
}
else
{
Console.WriteLine("\n {0} n'est pas dans la queue.\n", objet.ToString());
}
}
/// <summary>
/// Recherche d'un couple clé/valeur grâce à la valeur
/// </summary>
/// <param name="value">La valeur des couples clé/valeur que l'on veut récupérer</param>
public void RechercherValue(Coureur value)
{
Console.WriteLine("\n------ Recherche ------ \n");
if (_dictionary.ContainsValue(value))
{
int i = 1;
foreach (KeyValuePair <int, Coureur> entry in _dictionary)
{
if (entry.Value.Equals(value))
{
Console.WriteLine("n°{0} : {1}\n", i, entry.ToString());
}
i++;
}
}
else
{
Console.WriteLine("x-x Il n'y a aucune valeur correspondante à {0}.\n", value);
}
}
/// <summary>
/// Permet de Supprimer un des objets en fonction de lui-même (ici son nom)
/// </summary>
/// <param name="objet">L'objet que l'on souhaiterait Supprimer</param>
public void Supprimer(Coureur objet)
{
Console.WriteLine("\n------ Suppression ------ \n");
if (_queue.Contains(objet))
{
Queue <Coureur> res = new Queue <Coureur>();
foreach (Coureur entry in _queue)
{
if (!entry.Equals(objet))
{
res.Enqueue(entry);
}
}
_queue = res;
Console.WriteLine("L'objet {0} a été supprimé.\n", objet.ToString());
}
else
{
Console.WriteLine("x-x La collection ne contient pas cet objet {0}.\n", objet.ToString());
}
}
/// <summary>
/// Supprime l'objet mis en paramètre
/// </summary>
/// <param name="objet">L'objet que l'on veut Supprimer</param>
public void Supprimer(Coureur objet)
{
Console.WriteLine("\n------ Suppression ------ \n");
if (_stack.Contains(objet))
{
Stack <Coureur> res = new Stack <Coureur>();
foreach (Coureur entry in _stack)
{
if (!entry.Equals(objet))
{
res.Push(entry);
}
else
{
Console.WriteLine("L'objet {0} a été supprimé.\n", entry.ToString());
}
}
_stack = res;
}
Console.WriteLine("x-x La collection ne contient pas cet objet {0}.\n", objet.ToString());
}
/// <summary>
/// Surcharge de la méthode CompareTo, obligatoire pour IComparable
/// On choisit de faire la comparaison des noms des coureurs : ce sera suivant l'ordre alphabétique
/// </summary>
/// <param name="other">L'objet que l'on compare à l'instance de cette classe</param>
/// <returns>Un int correspondant au résultat de la comparaison (-1 si instance plus petit, 0 si égaux, 1 sinon)</returns>
public int CompareTo(Object other)
{
int res = -1;
if (other == null)
{
res = 1;
}
else
{
Coureur otherCoureur = other as Coureur;
if (otherCoureur != null)
{
res = this.Nom.CompareTo(otherCoureur.Nom);
}
else
{
throw new ArgumentException("Pas un coureur !");
}
}
return(res);
}
/// <summary>
/// Trier une collection dans l'ordre croissant des clés
/// </summary>
public void TriKey()
{
Dictionary <Int32, Coureur> res = new Dictionary <Int32, Coureur>();
Coureur valeurRes = new Coureur();
int min = Int32.MaxValue;
int max = Int32.MinValue;
for (int i = 0; i < _dictionary.Count; i++)
{
foreach (KeyValuePair <Int32, Coureur> entry in _dictionary)
{
if (entry.Key < min && entry.Key > max)
{
min = entry.Key;
valeurRes = entry.Value;
}
}
res.Add(min, valeurRes);
max = min;
min = Int32.MaxValue;
}
_dictionary = res;
}
/// <summary>
/// Ajout d'un objet dans la collection
/// </summary>
/// <param name="objet">L'objet que l'on souhaite Ajouter</param>
public void Ajouter(Coureur objet)
{
Console.WriteLine("\n------ Ajout ------ \n");
_queue.Enqueue(objet);
Console.WriteLine("{0} a été ajouté.\n", objet.ToString());
}
static void Main(string[] args)
{
Coureur coureur1 = new Coureur(2, "Maggie");
Coureur coureur2 = new Coureur(11, "Rosita");
Coureur coureur3 = new Coureur(15, "Michonne");
Coureur coureur4 = new Coureur(2, "Judith");
Coureur coureur5 = new Coureur(5, "Glenn");
Coureur coureur6 = new Coureur(27, "Rick");
Coureur coureur7 = new Coureur(1, "Abraham");
Coureur coureur8 = new Coureur(42, "Jesus");
Coureur coureur9 = new Coureur(24, "Daryl");
Console.WriteLine("\n Que voulez-vous faire ?\n\n");
Console.WriteLine("\n 1 : Travailler sur une collection générique ? \n");
Console.WriteLine("\n 2 : Travailler sur une collection non générique ? \n\n");
int nombre = 0;
try
{
nombre = int.Parse(Console.In.ReadLine());
}
catch (Exception e)
{
Console.Out.WriteLine("L'erreur suivante s'est produite : " + e.Message);
}
Console.Clear();
Console.WriteLine("\n -----------------------------------------------------\n");
if (nombre == 1)
{
Console.WriteLine("--> Vous avez choisi de tester une collection générique.\n\n");
Console.WriteLine(" 1 = Utilisation de Dictionary < Int32, Coureur >\n");
Console.WriteLine(" 2 = Utilisation de Queue < Coureur >\n");
Console.WriteLine(" 3 = Utilisation de Stack < Coureur >\n");
try
{
nombre = int.Parse(Console.In.ReadLine());
}
catch (Exception e)
{
Console.Out.WriteLine("L'erreur suivante s'est produite : " + e.Message);
}
Console.Clear();
switch (nombre)
{
case 1:
Generique_Dictionnaire dictionnaire = new Generique_Dictionnaire();
Console.WriteLine("\n -----------------------------------------------------\n");
Console.WriteLine(" Création d'un Dictionary < Int32, Coureur >");
Console.WriteLine("\n -----------------------------------------------------\n\n");
dictionnaire.Ajouter(12, coureur1);
dictionnaire.Ajouter(2, coureur2);
dictionnaire.Ajouter(34, coureur3);
dictionnaire.Ajouter(14, coureur4);
dictionnaire.Ajouter(5, coureur5);
dictionnaire.Ajouter(67, coureur6);
dictionnaire.Ajouter(17, coureur7);
dictionnaire.Ajouter(98, coureur8);
dictionnaire.Ajouter(97, coureur9);
dictionnaire.RechercherKey(5);
dictionnaire.TriKey();
dictionnaire.Afficher();
dictionnaire.Supprimer(5);
dictionnaire.Supprimer(1);
dictionnaire.RechercherKey(5);
dictionnaire.RechercherValue(coureur9);
dictionnaire.Inserer(4, new Coureur(1, "Negan"), 1);
dictionnaire.Afficher();
dictionnaire.SupprimerDictionary();
dictionnaire.Afficher();
break;
case 2:
Generique_Queue queue = new Generique_Queue();
Console.WriteLine("\n -----------------------------------------------------\n");
Console.WriteLine(" Création d'une Queue < Coureur >");
Console.WriteLine("\n -----------------------------------------------------\n\n");
queue.Ajouter(coureur1);
queue.Ajouter(coureur2);
queue.Ajouter(coureur3);
queue.Ajouter(coureur4);
queue.Ajouter(coureur5);
queue.Ajouter(coureur6);
queue.Ajouter(coureur7);
queue.Ajouter(coureur8);
queue.Ajouter(coureur9);
queue.Afficher();
queue.Rechercher(coureur1);
queue.Supprimer(coureur5);
queue.SupprimerIndex(7);
queue.Rechercher(coureur5);
queue.Inserer(coureur5, 2);
queue.Afficher();
queue.Tri();
queue.Afficher();
queue.SupprimerQueue();
queue.Afficher();
break;
case 3:
Generique_Stack stack = new Generique_Stack();
Console.WriteLine("\n -----------------------------------------------------\n");
Console.WriteLine(" Création d'un Stack < Coureur >");
Console.WriteLine("\n -----------------------------------------------------\n\n");
stack.Ajouter(coureur1);
stack.Ajouter(coureur2);
stack.Ajouter(coureur3);
stack.Ajouter(coureur4);
stack.Ajouter(coureur5);
stack.Ajouter(coureur6);
stack.Ajouter(coureur7);
stack.Ajouter(coureur8);
stack.Ajouter(coureur9);
stack.Supprimer(coureur7);
stack.Afficher();
stack.Inserer(coureur7, 4);
stack.Afficher();
stack.Rechercher(coureur9);
stack.Afficher();
stack.Tri();
stack.Afficher();
stack.SupprimerStack();
stack.Afficher();
break;
default:
Console.WriteLine("Le numéro tapé ne correspond à rien.");
break;
}
}
else if (nombre == 2)
{
Console.WriteLine("--> Vous avez choisi de tester une collection générique.\n\n");
Console.WriteLine(" 1 = Utilisation de Hashtable\n");
Console.WriteLine(" 2 = Utilisation de SortedList\n");
Console.WriteLine(" 3 = Utilisation de Queue\n");
try
{
nombre = int.Parse(Console.In.ReadLine());
}
catch (Exception e)
{
Console.Out.WriteLine("L'erreur suivante s'est produite : " + e.Message);
}
Console.Clear();
switch (nombre)
{
case 1:
NonGenerique_Hashtable hashtable = new NonGenerique_Hashtable();
Console.WriteLine("\n -----------------------------------------------------\n");
Console.WriteLine(" Création d'une Hashtable");
Console.WriteLine("\n -----------------------------------------------------\n\n");
hashtable.Ajouter(coureur1, "Rhee");
hashtable.Ajouter(coureur1.Nom, true);
hashtable.Ajouter(coureur1.Nom, 15);
hashtable.Ajouter(coureur9, null);
hashtable.Ajouter(coureur8.Maillot, false);
hashtable.Ajouter(coureur8, "Paul Rovia");
hashtable.Ajouter(coureur5, "Rhee");
hashtable.Afficher();
hashtable.RechercherValue("Rhee");
hashtable.RechercherValue(null);
hashtable.RechercherKey(coureur7);
hashtable.RechercherKey(coureur9);
hashtable.SupprimerKey(coureur5);
hashtable.Afficher();
hashtable.SupprimerHashtable();
hashtable.Afficher();
break;
case 2:
NonGenerique_SortedList sortedList = new NonGenerique_SortedList();
Console.WriteLine("\n -----------------------------------------------------\n");
Console.WriteLine(" Création d'une SortedList");
Console.WriteLine("\n -----------------------------------------------------\n\n");
sortedList.Ajouter(coureur2, coureur1);
sortedList.Ajouter(coureur3, coureur4);
sortedList.Ajouter(coureur9, coureur8.Maillot);
sortedList.Ajouter(coureur8, coureur7.Nom);
sortedList.Ajouter(coureur1, null);
sortedList.Afficher();
sortedList.SupprimerIndex(sortedList.RecupererIndexKey(coureur9));
sortedList.Afficher();
sortedList.SupprimerKey(coureur8);
sortedList.Afficher();
sortedList.Ajouter(coureur1, coureur8);
sortedList.Ajouter(coureur7, coureur4);
sortedList.RechercherKey(coureur8);
sortedList.RechercherValue(coureur4);
sortedList.Ajouter(coureur4, null);
sortedList.RechercherValue(null);
sortedList.Rechercher(coureur1);
sortedList.SupprimerCollection();
sortedList.Afficher();
break;
case 3:
NonGenerique_Queue queue = new NonGenerique_Queue();
Console.WriteLine("\n -----------------------------------------------------\n");
Console.WriteLine(" Création d'une Queue");
Console.WriteLine("\n -----------------------------------------------------\n\n");
queue.Ajouter(coureur1);
queue.Ajouter(true);
queue.Ajouter(coureur7.Nom);
queue.Ajouter(coureur4.Nom + " a comme numéro de maillot le n° " + coureur4.Maillot);
queue.Afficher();
queue.Inserer("Negan", 2);
queue.Afficher();
queue.Rechercher("Negan");
queue.Inserer(true, 2);
queue.Afficher();
queue.Rechercher(true);
queue.Supprimer(true);
queue.Rechercher(true);
queue.Afficher();
queue.SupprimerQueue();
queue.Afficher();
break;
default: Console.WriteLine("Le numéro tapé ne correspond à rien.");
break;
}
}
}
/// <summary>
/// Clonage du coureur mis en paramètre
/// </summary>
/// <param name="objet">Le coureur que l'on veut copier</param>
public void Copie(Coureur objet)
{
this._maillot = objet.Maillot;
this._nom = objet.Nom;
}
