/// <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; }