diff --git a/cpp09/ex02/PmergeMe.cpp b/cpp09/ex02/PmergeMe.cpp index e69de29..62709fb 100644 --- a/cpp09/ex02/PmergeMe.cpp +++ b/cpp09/ex02/PmergeMe.cpp @@ -0,0 +1,106 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* PmergeMe.cpp :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: fgras-ca +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/03/07 13:12:20 by fgras-ca #+# #+# */ +/* Updated: 2024/03/07 14:04:03 by fgras-ca ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "PmergeMe.hpp" + +// Constructeur par défaut +PmergeMe::PmergeMe() +{ + std::cout << GREEN << "PmergeMe default constructor called!" << RESET << std::endl; +} +// Destructeur +PmergeMe::~PmergeMe() +{ + std::cout << RED << "PmergeMe is destroyed!" << RESET << std::endl; +} +// Constructeur de copie +PmergeMe::PmergeMe(const PmergeMe& other) +{ + std::cout << CYAN << "Copy constructor called for PmergeMe." << RESET << std::endl; + (void)other;// La copie des membres pourrait être ajoutée ici si nécessaire +} +// Opérateur d'affectation +PmergeMe& PmergeMe::operator=(const PmergeMe& other) +{ + std::cout << YELLOW << "Copy assignment PmergeMe operator called." << RESET << std::endl; + if (this != &other) + { + // Copie des membres pourrait être ajoutée ici si nécessaire + } + return (*this); +} + +void PmergeMe::sortAndDisplay(const std::vector& input) +{ + std::vector data = input; // Copie pour permettre le tri + measureAndSort(data, "std::vector"); +} + +void PmergeMe::sortAndDisplay(const std::list& input) +{ + std::list data = input; // Copie pour permettre le tri + measureAndSort(data, "std::list"); +} +// Fonction template pour appliquer un algorithme de tri similaire à Ford-Johnson sur un conteneur générique +// Elle divise récursivement le conteneur et le fusionne en utilisant des stratégies d'insertion. +template +void PmergeMe::fordJohnsonLikeSort(Container& container, typename Container::iterator begin, typename Container::iterator end) +{ + if (std::distance(begin, end) <= 1) + return; // Condition de base pour arrêter la récursivité + + typename Container::iterator median = begin; + std::advance(median, std::distance(begin, end) / 2); // Calcul de la position médiane + // Tri récursif des moitiés + fordJohnsonLikeSort(container, begin, median); + fordJohnsonLikeSort(container, median, end); + // La fusion ou l'insertion pourrait être effectuée ici + // Exemple simplifié utilisant std::inplace_merge pour des conteneurs supportant les itérateurs aléatoires + std::inplace_merge(begin, median, end); +} +// Affichage de la séquence +template +void PmergeMe::displaySequence(const Container& sequence, const std::string& prefix) +{ + std::cout << prefix << ": "; + for (typename Container::const_iterator it = sequence.begin(); it != sequence.end(); ++it) + { + std::cout << *it << " "; + } + std::cout << std::endl; +} +// Mesure du temps de tri et affichage +template +void PmergeMe::measureAndSort(Container& container, const std::string& containerName) { + displaySequence(container, "Before"); + + std::clock_t start = std::clock(); + fordJohnsonLikeSort(container, container.begin(), container.end()); + std::clock_t end = std::clock(); + + displaySequence(container, "After"); + + double duration = static_cast(end - start) / CLOCKS_PER_SEC * 1000000; // Convertir en microsecondes + std::cout << "Time to process a range of " << container.size() + << " elements with " << containerName << " : " << duration << " us\n"; +} +// Spécialisations explicites pour std::vector et std::list +template void PmergeMe::fordJohnsonLikeSort >(std::vector&, std::vector::iterator, std::vector::iterator); +template void PmergeMe::fordJohnsonLikeSort >(std::list&, std::list::iterator, std::list::iterator); + +template void PmergeMe::displaySequence >(const std::vector&, const std::string&); +template void PmergeMe::displaySequence >(const std::list&, const std::string&); + +template void PmergeMe::measureAndSort >(std::vector&, const std::string&); + +// Spécialisation explicite pour std::list +template void PmergeMe::measureAndSort >(std::list&, const std::string&); diff --git a/cpp09/ex02/PmergeMe.hpp b/cpp09/ex02/PmergeMe.hpp index 5a21aab..20c4f1c 100644 --- a/cpp09/ex02/PmergeMe.hpp +++ b/cpp09/ex02/PmergeMe.hpp @@ -6,7 +6,7 @@ /* By: fgras-ca +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/03/06 16:17:28 by fgras-ca #+# #+# */ -/* Updated: 2024/03/06 17:18:48 by fgras-ca ### ########.fr */ +/* Updated: 2024/03/07 14:00:07 by fgras-ca ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,27 +16,55 @@ #include #include #include +#include +#include +#include // Pour les conteneurs supportant le tri direct +#include // Pour std::distance et std::advance +#include // Pour std::atoi +#define RESET "\033[0m" +#define BLACK "\033[30m" +#define RED "\033[31m" +#define GREEN "\033[32m" +#define YELLOW "\033[33m" +#define BLUE "\033[34m" +#define MAGENTA "\033[35m" +#define CYAN "\033[36m" +#define WHITE "\033[37m" +#define ORANGE "\033[38;5;214m" + +// Définition de la classe PmergeMe pour implémenter un algorithme de tri inspiré du Ford-Johnson class PmergeMe { public: + // Constructeur par défaut PmergeMe(); + // Destructeur ~PmergeMe(); + // Constructeur de copie PmergeMe(const PmergeMe& other); + // Opérateur d'affectation PmergeMe& operator=(const PmergeMe& other); - + // Méthodes publiques pour trier et afficher des séquences d'entiers + // Ces méthodes acceptent un std::vector ou un std::list comme conteneur d'entrée void sortAndDisplay(const std::vector& input); void sortAndDisplay(const std::list& input); private: + // Fonction template pour le tri récursif inspiré de Ford-Johnson + // C'est une version simplifiée destinée à montrer la structure générale et à être adaptée template - void forJohnsonSort(Container& container); - + void fordJohnsonLikeSort(Container& container, typename Container::iterator begin, typename Container::iterator end); + // Fonction template pour fusionner deux sous-séquences triées + // Utilise std::inplace_merge pour les conteneurs supportant les itérateurs aléatoires + template + void merge(Container& container, typename Container::iterator begin, typename Container::iterator median, typename Container::iterator end); + // Fonction template pour afficher les éléments d'une séquence, précédés d'un préfixe template void displaySequence(const Container& sequence, const std::string& prefix); - + // Fonction template pour mesurer et afficher le temps de tri d'une séquence template - void mesureAndSort(Container& container); + void measureAndSort(Container& container, const std::string& containerName); }; -#endif \ No newline at end of file +#endif diff --git a/cpp09/ex02/main.cpp b/cpp09/ex02/main.cpp index e69de29..431b5ff 100644 --- a/cpp09/ex02/main.cpp +++ b/cpp09/ex02/main.cpp @@ -0,0 +1,49 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* main.cpp :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: fgras-ca +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/03/07 13:25:02 by fgras-ca #+# #+# */ +/* Updated: 2024/03/07 13:56:19 by fgras-ca ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "PmergeMe.hpp" + +int main(int argc, char* argv[]) +{ + if(argc < 2) + { + std::cerr << "Usage: " << argv[0] << " " << std::endl; + return (1); + } + + PmergeMe pmerge; + std::vector vectorInput; + std::list listInput; + + // Remplir les conteneurs avec les entiers fournis en arguments + for(int i = 1; i < argc; ++i) + { + int value = std::atoi(argv[i]); + if(value < 0) + { + std::cerr << "Error: Only positive integers are allowed." << std::endl; + return (1); + } + vectorInput.push_back(value); + listInput.push_back(value); + } + + // Traitement et affichage pour std::vector + std::cout << "Processing with std::vector..." << std::endl; + pmerge.sortAndDisplay(vectorInput); + + // Traitement et affichage pour std::list + std::cout << "\nProcessing with std::list..." << std::endl; + pmerge.sortAndDisplay(listInput); + + return (0); +}