cpp09ex02

cpp09/ex02/PmergeMe.cpp

@@ -0,0 +1,106 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   PmergeMe.cpp                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: fgras-ca <fgras-ca@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   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<int>& input)
+{
+	std::vector<int> data = input; // Copie pour permettre le tri
+	measureAndSort(data, "std::vector<int>");
+}
+
+void PmergeMe::sortAndDisplay(const std::list<int>& input)
+{
+	std::list<int> data = input; // Copie pour permettre le tri
+	measureAndSort(data, "std::list<int>");
+}
+// 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<typename Container>
+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<typename Container>
+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<typename Container>
+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<double>(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<int> et std::list<int>
+template void PmergeMe::fordJohnsonLikeSort<std::vector<int> >(std::vector<int>&, std::vector<int>::iterator, std::vector<int>::iterator);
+template void PmergeMe::fordJohnsonLikeSort<std::list<int> >(std::list<int>&, std::list<int>::iterator, std::list<int>::iterator);
+
+template void PmergeMe::displaySequence<std::vector<int> >(const std::vector<int>&, const std::string&);
+template void PmergeMe::displaySequence<std::list<int> >(const std::list<int>&, const std::string&);
+
+template void PmergeMe::measureAndSort<std::vector<int> >(std::vector<int>&, const std::string&);
+
+// Spécialisation explicite pour std::list<int>
+template void PmergeMe::measureAndSort<std::list<int> >(std::list<int>&, const std::string&);

cpp09/ex02/PmergeMe.hpp

@@ -6,7 +6,7 @@
 /*   By: fgras-ca <fgras-ca@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   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 <vector>
 #include <list>
 #include <string>
+#include <iostream>
+#include <ctime>
+#include <algorithm> // Pour les conteneurs supportant le tri direct
+#include <iterator>  // Pour std::distance et std::advance
+#include <cstdlib> // 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<int> ou un std::list<int> comme conteneur d'entrée
 	void sortAndDisplay(const std::vector<int>& input);
 	void sortAndDisplay(const std::list<int>& 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<typename Container>
-	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<typename Container>
+	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<typename Container>
 	void displaySequence(const Container& sequence, const std::string& prefix);
-
+	// Fonction template pour mesurer et afficher le temps de tri d'une séquence
 	template<typename Container>
-	void mesureAndSort(Container& container);
+	void measureAndSort(Container& container, const std::string& containerName);
 };
 
-#endif
+#endif

cpp09/ex02/main.cpp

@@ -0,0 +1,49 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   main.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: fgras-ca <fgras-ca@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   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] << " <sequence of integers>" << std::endl;
+		return (1);
+	}
+
+	PmergeMe pmerge;
+	std::vector<int> vectorInput;
+	std::list<int> 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<int>..." << std::endl;
+	pmerge.sortAndDisplay(vectorInput);
+
+	// Traitement et affichage pour std::list
+	std::cout << "\nProcessing with std::list<int>..." << std::endl;
+	pmerge.sortAndDisplay(listInput);
+
+	return (0);
+}