From 86b9f07d7be708424a77c19cd3fff661a2f998e5 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 12 Oct 2020 14:15:25 +0200
Subject: [PATCH 01/23] Initial commit [SkipList]

- insert of first and second element
- display function
---
 tp3/makefile         |  19 ++++++
 tp3/src/SkipList.cpp | 149 +++++++++++++++++++++++++++++++++++++++++++
 tp3/src/SkipList.h   |  50 +++++++++++++++
 tp3/src/element.cpp  |   9 +++
 tp3/src/element.h    |  10 +++
 tp3/src/main.cpp     |  14 ++++
 6 files changed, 251 insertions(+)
 create mode 100644 tp3/makefile
 create mode 100644 tp3/src/SkipList.cpp
 create mode 100644 tp3/src/SkipList.h
 create mode 100644 tp3/src/element.cpp
 create mode 100644 tp3/src/element.h
 create mode 100644 tp3/src/main.cpp

diff --git a/tp3/makefile b/tp3/makefile
new file mode 100644
index 0000000..d839cf9
--- /dev/null
+++ b/tp3/makefile
@@ -0,0 +1,19 @@
+all: bin/executable.out
+
+bin/executable.out: obj/main.o obj/SkipList.o obj/element.o
+	g++ -Wall -g obj/main.o obj/SkipList.o obj/element.o -o bin/executable.out
+
+obj/main.o: src/main.cpp src/SkipList.h src/element.h
+	g++ -Wall -g -c src/main.cpp -o obj/main.o
+
+obj/SkipList.o: src/SkipList.h src/SkipList.cpp src/element.h
+	g++ -Wall -g -c src/SkipList.cpp -o obj/SkipList.o
+
+obj/element.o: src/element.h src/element.cpp
+	g++ -Wall -g -c src/element.cpp -o obj/element.o
+
+clean:
+	rm obj/*
+
+veryclean: clean
+	rm bin/*
\ No newline at end of file
diff --git a/tp3/src/SkipList.cpp b/tp3/src/SkipList.cpp
new file mode 100644
index 0000000..7167e75
--- /dev/null
+++ b/tp3/src/SkipList.cpp
@@ -0,0 +1,149 @@
+#include "SkipList.h"
+
+SkipList::SkipList () {
+	ad = new Cellule;
+	ad->niveaux.push_back(nullptr);
+	count = 0;
+	nb_niveaux = 1;
+}
+
+SkipList::~SkipList () {
+	
+}
+
+bool SkipList::estVide() { return count == 0; }
+
+void SkipList::inserer (const Elem& e) {
+	if (estVide()) {
+		Cellule* snt = new Cellule;
+		snt->info = e;
+		snt->niveaux.push_back(nullptr);
+		ad->niveaux[0] = snt;
+		// ad = new Cellule;
+		// ad->info = e;
+		// ad->niveaux.push_back(nullptr);
+		++count;
+	}
+	else if (count == 1) {
+		if (e < ad->niveaux[0]->info) {
+			Cellule* temp = ad->niveaux[0];
+			ad->niveaux[0] = new Cellule;
+			ad->niveaux[0]->info = e;
+			ad->niveaux[0]->niveaux.push_back(temp);
+
+			srand(time(NULL));
+			unsigned int rand_num = rand() % 2;
+
+			while(rand_num) {
+				ad->niveaux[0]->niveaux.push_back(nullptr);
+				ad->niveaux.push_back(ad->niveaux[0]);
+				++nb_niveaux;
+
+				rand_num = rand() % 2;
+			}
+
+			// Cellule* temp = ad;
+			// ad = new Cellule;
+			// ad->info = e;
+			// ad->niveaux.push_back(temp);
+
+			// srand(time(NULL));
+			// unsigned int rand_num = rand() % 2;
+
+			// while(rand_num) {
+			// 	ad->niveaux.push_back(nullptr);
+			// 	++nb_niveaux;
+
+			// 	rand_num = rand() % 2;
+			// }
+
+			++count;
+		}
+		else if (e > ad->niveaux[0]->info) {
+
+			Cellule* temp = new Cellule;
+			temp->info = e;
+			temp->niveaux.push_back(nullptr);
+			ad->niveaux[0]->niveaux[0] = temp;
+
+			srand(time(NULL));
+			unsigned int rand_num = rand() % 2;
+
+			while(rand_num) {
+				temp->niveaux.push_back(nullptr);
+				ad->niveaux.push_back(temp);
+				++nb_niveaux;
+
+				rand_num = rand() % 2;
+			}
+
+			// Cellule* temp = new Cellule;
+			// temp->info = e;
+			// temp->niveaux.push_back(nullptr);
+			// ad->niveaux[0] = temp;
+
+			// srand(time(NULL));
+			// unsigned int rand_num = rand() % 2;
+
+			// while(rand_num) {
+			// 	temp->niveaux.push_back(nullptr);
+			// 	++nb_niveaux;
+
+			// 	rand_num = rand() % 2;
+			// }
+
+			++count;
+		}
+	}
+	else {
+		unsigned int i = ad->niveaux.size()-1;
+
+		if(e < ad->niveaux.at(i)->info) {
+		}
+	}
+}
+
+void SkipList::afficher() const {
+	Cellule* current_address;
+	unsigned int current_lvl = nb_niveaux;
+	unsigned int current_lvl_index = current_lvl == 1 ? 0 : current_lvl-1;
+
+	while(current_lvl != 0) {
+		current_address = ad->niveaux[current_lvl_index];
+
+		std::cout << "LEVEL " << current_lvl << " | ";
+
+		while(current_address != nullptr) {
+			std::cout << "[" << current_address->info << "] -> ";
+
+			current_address = current_address->niveaux[current_lvl_index];
+		}
+
+		if (current_address == nullptr) {
+			std::cout << "NULL";
+		}
+
+		std::cout << std::endl;
+
+		--current_lvl_index;
+		--current_lvl;
+	}
+}
+
+// void SkipList::etablirProchainNiveau () {
+// 	Cellule* current_address = ad;
+// 	Cellule* temp = ad; // Derniere cellule sur laquelle on a eu pile
+
+// 	unsigned int rand_num;
+// 	while(current_address != nullptr) {
+// 		srand(time(NULL));
+// 		rand_num = rand() % 2;
+
+// 		if (rand_num && temp != ad) {
+// 			temp->niveaux.push_back(current_address);
+// 			temp = current_address;
+// 		}
+
+// 		current_address = current_address->niveaux[current_address->niveaux.size()-1];
+// 	}
+// }
\ No newline at end of file
diff --git a/tp3/src/SkipList.h b/tp3/src/SkipList.h
new file mode 100644
index 0000000..4a65125
--- /dev/null
+++ b/tp3/src/SkipList.h
@@ -0,0 +1,50 @@
+#ifndef _SKIPLIST
+#define _SKIPLIST
+
+#include "element.h"
+#include <iostream>
+#include <vector>
+
+class SkipList;
+
+class Cellule {
+    friend class SkipList;
+
+    private:
+        Elem info;
+        std::vector<Cellule*> niveaux;
+};
+
+class SkipList {
+	public:
+        //Constructeurs-------------------------------------------------------------
+        SkipList();
+        //Postcondition : la SkipList initialisee est vide
+
+        SkipList(const SkipList & l);
+        //Postcondition : la SkipList initialisee et l correspondent a des SkipLists identiques
+        //                (mais elles sont totalement independantes l'une de l'autre)
+        
+        //Destructeur---------------------------------------------------------------
+        ~SkipList();
+
+        //Fonctions membres---------------------------------------------------------
+        void inserer(const Elem& e);
+        //Precondition : la Skip List est triee
+        //Postcondition : l'element "e" est insere dans la Skip List
+
+        void afficher() const;
+
+        bool estVide();
+
+        // void etablirProchainNiveau();
+        
+    private:
+
+        //Donnees membres-----------------------------------------------------------
+        Cellule *ad;
+        unsigned int count;
+        unsigned int nb_niveaux;
+};
+
+#endif
\ No newline at end of file
diff --git a/tp3/src/element.cpp b/tp3/src/element.cpp
new file mode 100644
index 0000000..ef9b7c3
--- /dev/null
+++ b/tp3/src/element.cpp
@@ -0,0 +1,9 @@
+// LIFAP6 - Automne 2017 - R. Chaine
+
+#include <cstdio> 
+#include "element.h"
+
+void affichageElement(const Elem & e)
+{
+  std::printf("%d ",e);
+}
diff --git a/tp3/src/element.h b/tp3/src/element.h
new file mode 100644
index 0000000..07448ad
--- /dev/null
+++ b/tp3/src/element.h
@@ -0,0 +1,10 @@
+// LIFAP6 - Automne 2017 - R. Chaine
+
+#ifndef _ELEMENT
+#define _ELEMENT
+
+typedef int Elem;
+
+void affichageElement(const Elem & e);
+
+#endif
diff --git a/tp3/src/main.cpp b/tp3/src/main.cpp
new file mode 100644
index 0000000..2234cb6
--- /dev/null
+++ b/tp3/src/main.cpp
@@ -0,0 +1,14 @@
+#include "SkipList.h"
+#include <iostream>
+
+int main() {
+	SkipList l;
+
+	l.inserer(5);
+	l.inserer(6);
+	l.inserer(4);
+
+	l.afficher();
+	
+	return 0;
+}
\ No newline at end of file
-- 
GitLab


From c0c9c25ef17a66eeb1d905c683797b1b3b14ca73 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 14 Oct 2020 14:18:09 +0200
Subject: [PATCH 02/23] Initial Commit [Table]

Tables de Hachage
---
 tp5/Table de Hachage/makefile        | 19 +++++++++++++++++++
 tp5/Table de Hachage/src/element.cpp |  9 +++++++++
 tp5/Table de Hachage/src/element.h   | 10 ++++++++++
 tp5/Table de Hachage/src/main.cpp    |  9 +++++++++
 tp5/Table de Hachage/src/table.cpp   |  1 +
 tp5/Table de Hachage/src/table.h     |  6 ++++++
 6 files changed, 54 insertions(+)
 create mode 100644 tp5/Table de Hachage/makefile
 create mode 100644 tp5/Table de Hachage/src/element.cpp
 create mode 100644 tp5/Table de Hachage/src/element.h
 create mode 100644 tp5/Table de Hachage/src/main.cpp
 create mode 100644 tp5/Table de Hachage/src/table.cpp
 create mode 100644 tp5/Table de Hachage/src/table.h

diff --git a/tp5/Table de Hachage/makefile b/tp5/Table de Hachage/makefile
new file mode 100644
index 0000000..125a879
--- /dev/null
+++ b/tp5/Table de Hachage/makefile	
@@ -0,0 +1,19 @@
+all: bin/executable.out
+
+bin/executable.out: obj/main.o obj/table.o obj/element.o
+	g++ -Wall -g obj/main.o obj/table.o obj/element.o -o bin/executable.out
+
+obj/main.o: src/main.cpp src/table.h src/element.h
+	g++ -Wall -g -c src/main.cpp -o obj/main.o
+
+obj/table.o: src/table.h src/table.cpp src/element.h
+	g++ -Wall -g -c src/table.cpp -o obj/table.o
+
+obj/element.o: src/element.h src/element.cpp
+	g++ -Wall -g -c src/element.cpp -o obj/element.o
+
+clean:
+	rm obj/*
+
+veryclean: clean
+	rm bin/*
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/element.cpp b/tp5/Table de Hachage/src/element.cpp
new file mode 100644
index 0000000..ef9b7c3
--- /dev/null
+++ b/tp5/Table de Hachage/src/element.cpp	
@@ -0,0 +1,9 @@
+// LIFAP6 - Automne 2017 - R. Chaine
+
+#include <cstdio> 
+#include "element.h"
+
+void affichageElement(const Elem & e)
+{
+  std::printf("%d ",e);
+}
diff --git a/tp5/Table de Hachage/src/element.h b/tp5/Table de Hachage/src/element.h
new file mode 100644
index 0000000..07448ad
--- /dev/null
+++ b/tp5/Table de Hachage/src/element.h	
@@ -0,0 +1,10 @@
+// LIFAP6 - Automne 2017 - R. Chaine
+
+#ifndef _ELEMENT
+#define _ELEMENT
+
+typedef int Elem;
+
+void affichageElement(const Elem & e);
+
+#endif
diff --git a/tp5/Table de Hachage/src/main.cpp b/tp5/Table de Hachage/src/main.cpp
new file mode 100644
index 0000000..5586453
--- /dev/null
+++ b/tp5/Table de Hachage/src/main.cpp	
@@ -0,0 +1,9 @@
+#include "element.h"
+#include "table.h"
+#include <cstdio>
+
+int main()
+{
+
+  return 0;
+}
diff --git a/tp5/Table de Hachage/src/table.cpp b/tp5/Table de Hachage/src/table.cpp
new file mode 100644
index 0000000..dae816d
--- /dev/null
+++ b/tp5/Table de Hachage/src/table.cpp	
@@ -0,0 +1 @@
+#include "table.h"
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/table.h b/tp5/Table de Hachage/src/table.h
new file mode 100644
index 0000000..fc38228
--- /dev/null
+++ b/tp5/Table de Hachage/src/table.h	
@@ -0,0 +1,6 @@
+#include "element.h"
+#include <iostream>
+
+class Table {
+	
+};
\ No newline at end of file
-- 
GitLab


From 8204258ae7c2c2f3ff6e3ae4d54bffcaeb6be724 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 14 Oct 2020 17:00:10 +0200
Subject: [PATCH 03/23] Table works [work in progress]

---
 tp5/Table de Hachage/src/element.cpp        |  9 ++--
 tp5/Table de Hachage/src/element.h          |  8 ++--
 tp5/Table de Hachage/src/hash_functions.cpp | 10 +++++
 tp5/Table de Hachage/src/table.cpp          | 40 +++++++++++++++++-
 tp5/Table de Hachage/src/table.h            | 47 +++++++++++++++++++--
 5 files changed, 100 insertions(+), 14 deletions(-)
 create mode 100644 tp5/Table de Hachage/src/hash_functions.cpp

diff --git a/tp5/Table de Hachage/src/element.cpp b/tp5/Table de Hachage/src/element.cpp
index ef9b7c3..021a81b 100644
--- a/tp5/Table de Hachage/src/element.cpp	
+++ b/tp5/Table de Hachage/src/element.cpp	
@@ -1,9 +1,6 @@
-// LIFAP6 - Automne 2017 - R. Chaine
-
-#include <cstdio> 
+#include <iostream> 
 #include "element.h"
 
-void affichageElement(const Elem & e)
-{
-  std::printf("%d ",e);
+void Element::affiche() const {
+	std::cout << key << std::endl;
 }
diff --git a/tp5/Table de Hachage/src/element.h b/tp5/Table de Hachage/src/element.h
index 07448ad..8f6afd1 100644
--- a/tp5/Table de Hachage/src/element.h	
+++ b/tp5/Table de Hachage/src/element.h	
@@ -1,10 +1,10 @@
-// LIFAP6 - Automne 2017 - R. Chaine
-
 #ifndef _ELEMENT
 #define _ELEMENT
 
-typedef int Elem;
+struct Element {
+	int key;
 
-void affichageElement(const Elem & e);
+	void affiche() const;
+};
 
 #endif
diff --git a/tp5/Table de Hachage/src/hash_functions.cpp b/tp5/Table de Hachage/src/hash_functions.cpp
new file mode 100644
index 0000000..69d1443
--- /dev/null
+++ b/tp5/Table de Hachage/src/hash_functions.cpp	
@@ -0,0 +1,10 @@
+#ifndef _HASH_FUNCTIONS
+#define _HASH_FUNCTIONS
+
+#include "element.h"
+
+unsigned int hash_modulo (const Key& k, unsigned int size) {
+	return k % size;
+}
+
+#endif
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/table.cpp b/tp5/Table de Hachage/src/table.cpp
index dae816d..b578371 100644
--- a/tp5/Table de Hachage/src/table.cpp	
+++ b/tp5/Table de Hachage/src/table.cpp	
@@ -1 +1,39 @@
-#include "table.h"
\ No newline at end of file
+#include "table.h"
+#include "hash_functions.cpp"
+#include <iostream>
+
+Table::Table (unsigned int size) {
+	max_elements = size;
+	nb_elements = 0;
+
+	elements = new Case[size];
+	hash = hash_modulo;
+}
+
+Table::~Table () {
+	delete [] elements;
+}
+
+// void Table::add (const Element& e) {
+// 	assert(nb_elements < max_elements);
+
+// 	unsigned int hash_code = hash(e, max_elements);
+
+// 	while(!elements[hash_code].free) {
+// 		hash_code = hash_step(e.key, hash_code);
+// 	}
+
+// 	if (elements[hash_code].free) {
+// 		elements[hash_code].element = e;
+// 		elements[hash_code].free = false;
+// 		++nb_elements;
+// 	}
+// }
+
+// void Table::show () const {
+// 	for(unsigned int i=0; i<max_elements; ++i) {
+// 		if(!elements[i].free) {
+// 			std::cout << elements[i].
+// 		}
+// 	}
+// }
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/table.h b/tp5/Table de Hachage/src/table.h
index fc38228..1583775 100644
--- a/tp5/Table de Hachage/src/table.h	
+++ b/tp5/Table de Hachage/src/table.h	
@@ -1,6 +1,47 @@
+#ifndef _TABLE
+#define _TABLE
+
+typedef int Key;
+
 #include "element.h"
-#include <iostream>
+
+class Table;
+
+class Case {
+	friend class Table;
+
+	private:
+		Element element;
+		bool free;
+
+	public:
+		Case() : free(true) {}
+		Case(const Element& e) : element(e), free(false) {}
+
+		void set(const Element& e) { element=e; free=false; }
+		Element get() const { return element; }
+
+		bool isFree() const { return free; }
+};
 
 class Table {
-	
-};
\ No newline at end of file
+	private:
+		Case* elements;
+
+		unsigned int max_elements;
+		unsigned int nb_elements;
+
+		unsigned int (*hash)(const Key&, unsigned int);
+		unsigned int (*hash_step)(Key, unsigned int);
+
+	public:
+		Table(unsigned int size);
+		~Table();
+
+		void add(const Element& e);
+		void remove(unsigned int hash_code);
+		void show() const;
+
+};
+
+#endif
\ No newline at end of file
-- 
GitLab


From a1e0d4e4c6669f9aa41da15e8931846f20825f47 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 14 Oct 2020 17:18:48 +0200
Subject: [PATCH 04/23] Works Good

---
 tp5/Table de Hachage/src/element.h          |  4 +-
 tp5/Table de Hachage/src/hash_functions.cpp |  4 ++
 tp5/Table de Hachage/src/main.cpp           | 15 ++++--
 tp5/Table de Hachage/src/table.cpp          | 55 ++++++++++++---------
 tp5/Table de Hachage/src/table.h            |  3 +-
 5 files changed, 53 insertions(+), 28 deletions(-)

diff --git a/tp5/Table de Hachage/src/element.h b/tp5/Table de Hachage/src/element.h
index 8f6afd1..60786fc 100644
--- a/tp5/Table de Hachage/src/element.h	
+++ b/tp5/Table de Hachage/src/element.h	
@@ -1,8 +1,10 @@
 #ifndef _ELEMENT
 #define _ELEMENT
 
+typedef int Key;
+
 struct Element {
-	int key;
+	Key key;
 
 	void affiche() const;
 };
diff --git a/tp5/Table de Hachage/src/hash_functions.cpp b/tp5/Table de Hachage/src/hash_functions.cpp
index 69d1443..de191b4 100644
--- a/tp5/Table de Hachage/src/hash_functions.cpp	
+++ b/tp5/Table de Hachage/src/hash_functions.cpp	
@@ -7,4 +7,8 @@ unsigned int hash_modulo (const Key& k, unsigned int size) {
 	return k % size;
 }
 
+unsigned int pas_de_hash_lin (const Key& k, unsigned int numero_essai) {
+	return 1;
+}
+
 #endif
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/main.cpp b/tp5/Table de Hachage/src/main.cpp
index 5586453..33f1170 100644
--- a/tp5/Table de Hachage/src/main.cpp	
+++ b/tp5/Table de Hachage/src/main.cpp	
@@ -1,9 +1,18 @@
 #include "element.h"
 #include "table.h"
-#include <cstdio>
 
-int main()
-{
+int main() {
+  Table t(10);
+
+  Element e;
+  e.key = 5;
+
+  Element e2;
+  e2.key = 2;
+
+  t.add(e);
+  t.add(e2);
+  t.show();
 
   return 0;
 }
diff --git a/tp5/Table de Hachage/src/table.cpp b/tp5/Table de Hachage/src/table.cpp
index b578371..6185a2e 100644
--- a/tp5/Table de Hachage/src/table.cpp	
+++ b/tp5/Table de Hachage/src/table.cpp	
@@ -8,32 +8,41 @@ Table::Table (unsigned int size) {
 
 	elements = new Case[size];
 	hash = hash_modulo;
+	hash_step = pas_de_hash_lin;
 }
 
 Table::~Table () {
 	delete [] elements;
 }
 
-// void Table::add (const Element& e) {
-// 	assert(nb_elements < max_elements);
-
-// 	unsigned int hash_code = hash(e, max_elements);
-
-// 	while(!elements[hash_code].free) {
-// 		hash_code = hash_step(e.key, hash_code);
-// 	}
-
-// 	if (elements[hash_code].free) {
-// 		elements[hash_code].element = e;
-// 		elements[hash_code].free = false;
-// 		++nb_elements;
-// 	}
-// }
-
-// void Table::show () const {
-// 	for(unsigned int i=0; i<max_elements; ++i) {
-// 		if(!elements[i].free) {
-// 			std::cout << elements[i].
-// 		}
-// 	}
-// }
\ No newline at end of file
+void Table::add (const Element& e) {
+	assert(nb_elements < max_elements);
+
+	unsigned int hash_code = hash(e.key, max_elements);
+	unsigned int numero_essai = 1;
+
+	while(!elements[hash_code].free) {
+		hash_code += hash_step(e.key, numero_essai++);
+	}
+
+	if (elements[hash_code].free) {
+		elements[hash_code].element = e;
+		elements[hash_code].free = false;
+		++nb_elements;
+	}
+}
+
+void Table::show () const {
+	for(unsigned int i=0; i<max_elements; ++i) {
+		if(!elements[i].free) {
+			std::cout << "[" << elements[i].element.key << "]";
+			if (i==max_elements-1) std::cout << std::endl;
+			else std::cout << " , ";
+		}
+		else {
+			std::cout << "[ ]";
+			if (i==max_elements-1) std::cout << std::endl;
+			else std::cout << " , ";
+		}
+	}
+}
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/table.h b/tp5/Table de Hachage/src/table.h
index 1583775..42142f1 100644
--- a/tp5/Table de Hachage/src/table.h	
+++ b/tp5/Table de Hachage/src/table.h	
@@ -4,6 +4,7 @@
 typedef int Key;
 
 #include "element.h"
+#include <assert.h>
 
 class Table;
 
@@ -32,7 +33,7 @@ class Table {
 		unsigned int nb_elements;
 
 		unsigned int (*hash)(const Key&, unsigned int);
-		unsigned int (*hash_step)(Key, unsigned int);
+		unsigned int (*hash_step)(const Key&, unsigned int);
 
 	public:
 		Table(unsigned int size);
-- 
GitLab


From 0fa0ae2398255ece5ec824c3bc6f4a80744e221e Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 14 Oct 2020 23:02:36 +0200
Subject: [PATCH 05/23] Works Better

---
 tp5/Table de Hachage/makefile               | 11 +++----
 tp5/Table de Hachage/src/element.cpp        |  6 ----
 tp5/Table de Hachage/src/element.h          | 12 --------
 tp5/Table de Hachage/src/hash_functions.cpp |  4 +--
 tp5/Table de Hachage/src/key.h              |  6 ++++
 tp5/Table de Hachage/src/main.cpp           | 18 ++++++------
 tp5/Table de Hachage/src/table.cpp          | 32 ++++++++++-----------
 tp5/Table de Hachage/src/table.h            | 14 ++++-----
 8 files changed, 44 insertions(+), 59 deletions(-)
 delete mode 100644 tp5/Table de Hachage/src/element.cpp
 delete mode 100644 tp5/Table de Hachage/src/element.h
 create mode 100644 tp5/Table de Hachage/src/key.h

diff --git a/tp5/Table de Hachage/makefile b/tp5/Table de Hachage/makefile
index 125a879..76416f2 100644
--- a/tp5/Table de Hachage/makefile	
+++ b/tp5/Table de Hachage/makefile	
@@ -1,17 +1,14 @@
 all: bin/executable.out
 
-bin/executable.out: obj/main.o obj/table.o obj/element.o
-	g++ -Wall -g obj/main.o obj/table.o obj/element.o -o bin/executable.out
+bin/executable.out: obj/main.o obj/table.o
+	g++ -Wall -g obj/main.o obj/table.o -o bin/executable.out
 
-obj/main.o: src/main.cpp src/table.h src/element.h
+obj/main.o: src/main.cpp src/table.h src/key.h
 	g++ -Wall -g -c src/main.cpp -o obj/main.o
 
-obj/table.o: src/table.h src/table.cpp src/element.h
+obj/table.o: src/table.h src/table.cpp src/key.h
 	g++ -Wall -g -c src/table.cpp -o obj/table.o
 
-obj/element.o: src/element.h src/element.cpp
-	g++ -Wall -g -c src/element.cpp -o obj/element.o
-
 clean:
 	rm obj/*
 
diff --git a/tp5/Table de Hachage/src/element.cpp b/tp5/Table de Hachage/src/element.cpp
deleted file mode 100644
index 021a81b..0000000
--- a/tp5/Table de Hachage/src/element.cpp	
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <iostream> 
-#include "element.h"
-
-void Element::affiche() const {
-	std::cout << key << std::endl;
-}
diff --git a/tp5/Table de Hachage/src/element.h b/tp5/Table de Hachage/src/element.h
deleted file mode 100644
index 60786fc..0000000
--- a/tp5/Table de Hachage/src/element.h	
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef _ELEMENT
-#define _ELEMENT
-
-typedef int Key;
-
-struct Element {
-	Key key;
-
-	void affiche() const;
-};
-
-#endif
diff --git a/tp5/Table de Hachage/src/hash_functions.cpp b/tp5/Table de Hachage/src/hash_functions.cpp
index de191b4..e75ae99 100644
--- a/tp5/Table de Hachage/src/hash_functions.cpp	
+++ b/tp5/Table de Hachage/src/hash_functions.cpp	
@@ -1,13 +1,13 @@
 #ifndef _HASH_FUNCTIONS
 #define _HASH_FUNCTIONS
 
-#include "element.h"
+#include "key.h"
 
 unsigned int hash_modulo (const Key& k, unsigned int size) {
 	return k % size;
 }
 
-unsigned int pas_de_hash_lin (const Key& k, unsigned int numero_essai) {
+unsigned int hash_skip_linear (const Key& k, unsigned int try_nb) {
 	return 1;
 }
 
diff --git a/tp5/Table de Hachage/src/key.h b/tp5/Table de Hachage/src/key.h
new file mode 100644
index 0000000..cbe180a
--- /dev/null
+++ b/tp5/Table de Hachage/src/key.h	
@@ -0,0 +1,6 @@
+#ifndef _KEY
+#define _KEY
+
+typedef int Key;
+
+#endif
diff --git a/tp5/Table de Hachage/src/main.cpp b/tp5/Table de Hachage/src/main.cpp
index 33f1170..0268fab 100644
--- a/tp5/Table de Hachage/src/main.cpp	
+++ b/tp5/Table de Hachage/src/main.cpp	
@@ -1,17 +1,19 @@
-#include "element.h"
 #include "table.h"
 
 int main() {
   Table t(10);
 
-  Element e;
-  e.key = 5;
+  t.add(8);
+  t.add(2);
+  t.add(2);
+  t.add(2);
+  t.add(3);
+  t.add(7);
+  t.add(9);
+  t.add(4);
+  t.add(1);
+  t.add(6);
 
-  Element e2;
-  e2.key = 2;
-
-  t.add(e);
-  t.add(e2);
   t.show();
 
   return 0;
diff --git a/tp5/Table de Hachage/src/table.cpp b/tp5/Table de Hachage/src/table.cpp
index 6185a2e..d01a369 100644
--- a/tp5/Table de Hachage/src/table.cpp	
+++ b/tp5/Table de Hachage/src/table.cpp	
@@ -8,41 +8,41 @@ Table::Table (unsigned int size) {
 
 	elements = new Case[size];
 	hash = hash_modulo;
-	hash_step = pas_de_hash_lin;
+	hash_step = hash_skip_linear;
 }
 
 Table::~Table () {
 	delete [] elements;
 }
 
-void Table::add (const Element& e) {
+void Table::add (const Key& key) {
 	assert(nb_elements < max_elements);
 
-	unsigned int hash_code = hash(e.key, max_elements);
-	unsigned int numero_essai = 1;
+	unsigned int hash_code = hash(key, max_elements);
+	unsigned int try_nb = 1;
 
 	while(!elements[hash_code].free) {
-		hash_code += hash_step(e.key, numero_essai++);
+		hash_code += hash_step(key, try_nb++);
+		if(hash_code >= max_elements) {
+			hash_code = hash_code % max_elements;
+		}
 	}
 
 	if (elements[hash_code].free) {
-		elements[hash_code].element = e;
+		elements[hash_code].key = key;
 		elements[hash_code].free = false;
 		++nb_elements;
 	}
 }
 
 void Table::show () const {
+	std::cout << "Maximum elements: " << max_elements << std::endl;
+	std::cout << "Elements stored: " << nb_elements << std::endl;
 	for(unsigned int i=0; i<max_elements; ++i) {
-		if(!elements[i].free) {
-			std::cout << "[" << elements[i].element.key << "]";
-			if (i==max_elements-1) std::cout << std::endl;
-			else std::cout << " , ";
-		}
-		else {
-			std::cout << "[ ]";
-			if (i==max_elements-1) std::cout << std::endl;
-			else std::cout << " , ";
-		}
+		if(!elements[i].free) std::cout << "[" << elements[i].key << "]";
+		else std::cout << "[ ]";
+
+		if (i==max_elements-1) std::cout << std::endl;
+		else std::cout << "  ";
 	}
 }
\ No newline at end of file
diff --git a/tp5/Table de Hachage/src/table.h b/tp5/Table de Hachage/src/table.h
index 42142f1..10c7633 100644
--- a/tp5/Table de Hachage/src/table.h	
+++ b/tp5/Table de Hachage/src/table.h	
@@ -1,9 +1,7 @@
 #ifndef _TABLE
 #define _TABLE
 
-typedef int Key;
-
-#include "element.h"
+#include "key.h"
 #include <assert.h>
 
 class Table;
@@ -12,15 +10,15 @@ class Case {
 	friend class Table;
 
 	private:
-		Element element;
+		Key key;
 		bool free;
 
 	public:
 		Case() : free(true) {}
-		Case(const Element& e) : element(e), free(false) {}
+		Case(const Key& k) : key(k), free(false) {}
 
-		void set(const Element& e) { element=e; free=false; }
-		Element get() const { return element; }
+		void set(const Key& k) { key=k; free=false; }
+		Key get() const { return key; }
 
 		bool isFree() const { return free; }
 };
@@ -39,7 +37,7 @@ class Table {
 		Table(unsigned int size);
 		~Table();
 
-		void add(const Element& e);
+		void add(const Key& e);
 		void remove(unsigned int hash_code);
 		void show() const;
 
-- 
GitLab


From bd0819f9eab0db6cadc96297d48dc1984b8a0407 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 21 Oct 2020 14:22:04 +0200
Subject: [PATCH 06/23] Initial Commit [ABR]

---
 .../bin/executable.out                        | Bin 0 -> 32928 bytes
 tp6/ArbreBinaireDeRecherche/makefile          |  19 ++++++++++++++++++
 tp6/ArbreBinaireDeRecherche/obj/abr.o         | Bin 0 -> 37872 bytes
 tp6/ArbreBinaireDeRecherche/obj/element.o     | Bin 0 -> 8816 bytes
 tp6/ArbreBinaireDeRecherche/obj/main.o        | Bin 0 -> 3576 bytes
 tp6/ArbreBinaireDeRecherche/src/abr.cpp       |  10 +++++++++
 tp6/ArbreBinaireDeRecherche/src/abr.h         |  16 +++++++++++++++
 tp6/ArbreBinaireDeRecherche/src/element.cpp   |   9 +++++++++
 tp6/ArbreBinaireDeRecherche/src/element.h     |  10 +++++++++
 tp6/ArbreBinaireDeRecherche/src/main.cpp      |   7 +++++++
 10 files changed, 71 insertions(+)
 create mode 100755 tp6/ArbreBinaireDeRecherche/bin/executable.out
 create mode 100644 tp6/ArbreBinaireDeRecherche/makefile
 create mode 100644 tp6/ArbreBinaireDeRecherche/obj/abr.o
 create mode 100644 tp6/ArbreBinaireDeRecherche/obj/element.o
 create mode 100644 tp6/ArbreBinaireDeRecherche/obj/main.o
 create mode 100644 tp6/ArbreBinaireDeRecherche/src/abr.cpp
 create mode 100644 tp6/ArbreBinaireDeRecherche/src/abr.h
 create mode 100644 tp6/ArbreBinaireDeRecherche/src/element.cpp
 create mode 100644 tp6/ArbreBinaireDeRecherche/src/element.h
 create mode 100644 tp6/ArbreBinaireDeRecherche/src/main.cpp

diff --git a/tp6/ArbreBinaireDeRecherche/bin/executable.out b/tp6/ArbreBinaireDeRecherche/bin/executable.out
new file mode 100755
index 0000000000000000000000000000000000000000..0730e12a86b98ecd1b8fd95aa55692e18b8fea14
GIT binary patch
literal 32928
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

literal 0
HcmV?d00001

diff --git a/tp6/ArbreBinaireDeRecherche/makefile b/tp6/ArbreBinaireDeRecherche/makefile
new file mode 100644
index 0000000..3e2e967
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/makefile
@@ -0,0 +1,19 @@
+all: bin/executable.out
+
+bin/executable.out: obj/main.o obj/abr.o obj/element.o
+	g++ -Wall -g obj/main.o obj/abr.o obj/element.o -o bin/executable.out
+
+obj/main.o: src/main.cpp src/abr.h src/element.h
+	g++ -Wall -g -c src/main.cpp -o obj/main.o
+
+obj/abr.o: src/abr.h src/abr.cpp src/element.h
+	g++ -Wall -g -c src/abr.cpp -o obj/abr.o
+
+obj/element.o: src/element.h src/element.cpp
+	g++ -Wall -g -c src/element.cpp -o obj/element.o
+
+clean:
+	rm obj/*
+
+veryclean: clean
+	rm bin/*
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/obj/abr.o b/tp6/ArbreBinaireDeRecherche/obj/abr.o
new file mode 100644
index 0000000000000000000000000000000000000000..9af141c353199ffdda1ccc5a101b3accb9577b46
GIT binary patch
literal 37872
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
M{EwMp+`G>IzwmQ&T>t<8

literal 0
HcmV?d00001

diff --git a/tp6/ArbreBinaireDeRecherche/obj/element.o b/tp6/ArbreBinaireDeRecherche/obj/element.o
new file mode 100644
index 0000000000000000000000000000000000000000..eba3191f18a3a138a3143792870b4499934c2f9b
GIT binary patch
literal 8816
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
IlF`Ti2lP$a<^TWy

literal 0
HcmV?d00001

diff --git a/tp6/ArbreBinaireDeRecherche/obj/main.o b/tp6/ArbreBinaireDeRecherche/obj/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..c2f84b48c4f701fa10bf0a31cf27644a590a7714
GIT binary patch
literal 3576
zcmbtWUuauZ82|3QO`0xkmNr#eDiUy&%`LZ$jkQj@rRmb9P`c7BG8G9o$;}^@+=QE(
zQui>0!lV?T3W|aV`m{aiqoByZfe(Wrh@fx24Eo@Mdk_SL`F-b}lir=)BIp<HIp6pD
z{+@Hcb8g<st}dyH0)iAc2M3Zs0sagf@M*@TVH9GJ&+Xj5l-vGoteo5Jn>>k{+)j2s
zc{}%R_Sf9b_xoh}H4R>1=jYsRe!rZX8D$<$fSKjC?~J|v#&-|UxQ{#_#0qhF2Drn9
zhgXT$f^#(X1?raLx{j$@8=(Mc)xHExE*~H`<nlq{qYw<8$GLwYvjHJ>;7-ppOlk-b
zu11JeKF8rEKFkP?5vCreQTYl7h7M3AfH6053=^wpE<`+ls9pJF&;X^6tkn0`(P~(k
zjKsoPWFj)GjPysJK>TsgB4@)dg;!#@xDyZ#p9^at+?$x9MZ#gyD5wbx^~~llVemK_
zl1IO)XrTkMkgl8`*FxlFMV<@4JYJ5G_dozvVySU}V@%KT2|X_009=VtUFoq8GiW@R
z0yor3OdZ1|oS|jlgWJVMF^JU)S<HE4RCp0bMfoc-gd^)feBDaNE&()+x}}%eZR$j$
zXzMj%%!b)CEyoqGayKEy7~Q-7%`3mC6BwrO+S&}hu*Fn%6EM<LFHp@i%5a_DB@YA3
zYx(%%>C?$n{004aeL9|KI$g`0ubP%=*GniGcBwYMH8-1>O~n({c%ssAjMCLa+ip2#
z$!Xb%j$^m1D%kaE%>kbI0%gu(rO+@d4qFIJ)mlw+%50Pkd#X{d80}d;C7kw@gVKUs
zw9QQ2GU~Q@!Q3!QH4}52u+}P@0LzPuXX7XH#jfRa-C7efT_z>3C+GC()F~HrH+R&X
zK)JR7%2rgF80-)2;qIM4{7J53uVo<;y`e4+1+&|lnnNS5J8HrZc(fio^wVp;HwHE>
z{`^Se=Udik?je<7jM9GyBS4edO&DqJ*%V@L)?l#5dl?Pb`SwDL*MOaFAAIN#Mz_I;
zXCFlCQ-tUtYk<ik@Z=Hr{1N!US)pEs!t(0H%))Bn;?mNk?B&Ach0JQUAewVAiOne*
zmGK4E(}hy)YN2A(8<-=G4-wtERQul#U81^(2&eT3e3?Kb!iVt@c#uFO+84o-EZzX&
z1NfXK5Q%(=1TO3zbKxHT0hjR>Vnlt}y9tm#<-*L~+ta!Sr@S|~oR;u=Tway%r@4GZ
z!gsk`mT-s5+Y&D77V8k}<z{e8vVV%pUr6{hF5i{#Jud&mXL*0byP&-6Gsx{kkIME-
zN5qM9oc7+k|Dbo?Y&u2}XUBHun&51+Vd##z<$zu`90T-Xrvo}e%Vx1#E!3?_3w4Y)
zig+n*KB6{k!>XE(x-{yRDO@lQ=%rSZJ`<o@cu(ti%i}$b_cjk?)(REdXyUc{KPis>
zv{zz3MYuF)#Q7IE*?MUL1v)cnFNl1U2h4Gt&IS33UZ&42(KGlEF5j^4lhTLe{AbXH
zV*XeES@e}-Qd*J!4-z~i+tPjFxBe@9{U31$T0ixvy#5Sga!iEa9S(j=f`??=JnCeO
z%(J|ir#-&J%C_r>`PKhB|5OQos-J3?>#zI7L<qV(|EnZ;NX}39jbHvaPbB(;^3z$D
z^LG)Wn4(T(8QtUge-r?pMSd~AjkurxXS|`F{TKfo?k}0aUAZB-fygWDKjr?sTmi!m
z+&|qzTt=*4z#k*yw|{d!`$ykF;V<@;>XCC(>?j3A`jQtsf;|0Okp1Z!<hRt@{8C;+
Wy_e+m(|h&vU+0N#dYzG%{r>?+6E@HQ

literal 0
HcmV?d00001

diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.cpp b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
new file mode 100644
index 0000000..a096890
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
@@ -0,0 +1,10 @@
+#include "abr.h"
+#include <iostream>
+
+ABR::ABR () {
+	head = nullptr;
+}
+
+ABR::~ABR () {
+
+}
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
new file mode 100644
index 0000000..3cd0b24
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -0,0 +1,16 @@
+#include "element.h"
+
+struct Node {
+	Elem element;
+	Node* left;
+	Node* right;
+};
+
+class ABR {
+	private:
+		Node* head;
+
+	public:
+		ABR();
+		~ABR();
+};
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/element.cpp b/tp6/ArbreBinaireDeRecherche/src/element.cpp
new file mode 100644
index 0000000..ef9b7c3
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/src/element.cpp
@@ -0,0 +1,9 @@
+// LIFAP6 - Automne 2017 - R. Chaine
+
+#include <cstdio> 
+#include "element.h"
+
+void affichageElement(const Elem & e)
+{
+  std::printf("%d ",e);
+}
diff --git a/tp6/ArbreBinaireDeRecherche/src/element.h b/tp6/ArbreBinaireDeRecherche/src/element.h
new file mode 100644
index 0000000..07448ad
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/src/element.h
@@ -0,0 +1,10 @@
+// LIFAP6 - Automne 2017 - R. Chaine
+
+#ifndef _ELEMENT
+#define _ELEMENT
+
+typedef int Elem;
+
+void affichageElement(const Elem & e);
+
+#endif
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
new file mode 100644
index 0000000..7cee540
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -0,0 +1,7 @@
+#include "abr.h"
+
+int main() {
+  ABR a;
+
+  return 0;
+}
-- 
GitLab


From f3c8f47a565c2c948a8d82c29ee66824aa3259a3 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Sun, 25 Oct 2020 20:45:16 +0100
Subject: [PATCH 07/23] Display function completed

- bug with 'deep'
---
 .../bin/executable.out                        | Bin 32928 -> 0 bytes
 tp6/ArbreBinaireDeRecherche/obj/abr.o         | Bin 37872 -> 0 bytes
 tp6/ArbreBinaireDeRecherche/obj/element.o     | Bin 8816 -> 0 bytes
 tp6/ArbreBinaireDeRecherche/obj/main.o        | Bin 3576 -> 0 bytes
 tp6/ArbreBinaireDeRecherche/src/abr.cpp       | 138 +++++++++++++++++-
 tp6/ArbreBinaireDeRecherche/src/abr.h         |  11 ++
 tp6/ArbreBinaireDeRecherche/src/main.cpp      |  25 +++-
 7 files changed, 171 insertions(+), 3 deletions(-)
 delete mode 100755 tp6/ArbreBinaireDeRecherche/bin/executable.out
 delete mode 100644 tp6/ArbreBinaireDeRecherche/obj/abr.o
 delete mode 100644 tp6/ArbreBinaireDeRecherche/obj/element.o
 delete mode 100644 tp6/ArbreBinaireDeRecherche/obj/main.o

diff --git a/tp6/ArbreBinaireDeRecherche/bin/executable.out b/tp6/ArbreBinaireDeRecherche/bin/executable.out
deleted file mode 100755
index 0730e12a86b98ecd1b8fd95aa55692e18b8fea14..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 32928
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

diff --git a/tp6/ArbreBinaireDeRecherche/obj/abr.o b/tp6/ArbreBinaireDeRecherche/obj/abr.o
deleted file mode 100644
index 9af141c353199ffdda1ccc5a101b3accb9577b46..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 37872
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
M{EwMp+`G>IzwmQ&T>t<8

diff --git a/tp6/ArbreBinaireDeRecherche/obj/element.o b/tp6/ArbreBinaireDeRecherche/obj/element.o
deleted file mode 100644
index eba3191f18a3a138a3143792870b4499934c2f9b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8816
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
IlF`Ti2lP$a<^TWy

diff --git a/tp6/ArbreBinaireDeRecherche/obj/main.o b/tp6/ArbreBinaireDeRecherche/obj/main.o
deleted file mode 100644
index c2f84b48c4f701fa10bf0a31cf27644a590a7714..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3576
zcmbtWUuauZ82|3QO`0xkmNr#eDiUy&%`LZ$jkQj@rRmb9P`c7BG8G9o$;}^@+=QE(
zQui>0!lV?T3W|aV`m{aiqoByZfe(Wrh@fx24Eo@Mdk_SL`F-b}lir=)BIp<HIp6pD
z{+@Hcb8g<st}dyH0)iAc2M3Zs0sagf@M*@TVH9GJ&+Xj5l-vGoteo5Jn>>k{+)j2s
zc{}%R_Sf9b_xoh}H4R>1=jYsRe!rZX8D$<$fSKjC?~J|v#&-|UxQ{#_#0qhF2Drn9
zhgXT$f^#(X1?raLx{j$@8=(Mc)xHExE*~H`<nlq{qYw<8$GLwYvjHJ>;7-ppOlk-b
zu11JeKF8rEKFkP?5vCreQTYl7h7M3AfH6053=^wpE<`+ls9pJF&;X^6tkn0`(P~(k
zjKsoPWFj)GjPysJK>TsgB4@)dg;!#@xDyZ#p9^at+?$x9MZ#gyD5wbx^~~llVemK_
zl1IO)XrTkMkgl8`*FxlFMV<@4JYJ5G_dozvVySU}V@%KT2|X_009=VtUFoq8GiW@R
z0yor3OdZ1|oS|jlgWJVMF^JU)S<HE4RCp0bMfoc-gd^)feBDaNE&()+x}}%eZR$j$
zXzMj%%!b)CEyoqGayKEy7~Q-7%`3mC6BwrO+S&}hu*Fn%6EM<LFHp@i%5a_DB@YA3
zYx(%%>C?$n{004aeL9|KI$g`0ubP%=*GniGcBwYMH8-1>O~n({c%ssAjMCLa+ip2#
z$!Xb%j$^m1D%kaE%>kbI0%gu(rO+@d4qFIJ)mlw+%50Pkd#X{d80}d;C7kw@gVKUs
zw9QQ2GU~Q@!Q3!QH4}52u+}P@0LzPuXX7XH#jfRa-C7efT_z>3C+GC()F~HrH+R&X
zK)JR7%2rgF80-)2;qIM4{7J53uVo<;y`e4+1+&|lnnNS5J8HrZc(fio^wVp;HwHE>
z{`^Se=Udik?je<7jM9GyBS4edO&DqJ*%V@L)?l#5dl?Pb`SwDL*MOaFAAIN#Mz_I;
zXCFlCQ-tUtYk<ik@Z=Hr{1N!US)pEs!t(0H%))Bn;?mNk?B&Ach0JQUAewVAiOne*
zmGK4E(}hy)YN2A(8<-=G4-wtERQul#U81^(2&eT3e3?Kb!iVt@c#uFO+84o-EZzX&
z1NfXK5Q%(=1TO3zbKxHT0hjR>Vnlt}y9tm#<-*L~+ta!Sr@S|~oR;u=Tway%r@4GZ
z!gsk`mT-s5+Y&D77V8k}<z{e8vVV%pUr6{hF5i{#Jud&mXL*0byP&-6Gsx{kkIME-
zN5qM9oc7+k|Dbo?Y&u2}XUBHun&51+Vd##z<$zu`90T-Xrvo}e%Vx1#E!3?_3w4Y)
zig+n*KB6{k!>XE(x-{yRDO@lQ=%rSZJ`<o@cu(ti%i}$b_cjk?)(REdXyUc{KPis>
zv{zz3MYuF)#Q7IE*?MUL1v)cnFNl1U2h4Gt&IS33UZ&42(KGlEF5j^4lhTLe{AbXH
zV*XeES@e}-Qd*J!4-z~i+tPjFxBe@9{U31$T0ixvy#5Sga!iEa9S(j=f`??=JnCeO
z%(J|ir#-&J%C_r>`PKhB|5OQos-J3?>#zI7L<qV(|EnZ;NX}39jbHvaPbB(;^3z$D
z^LG)Wn4(T(8QtUge-r?pMSd~AjkurxXS|`F{TKfo?k}0aUAZB-fygWDKjr?sTmi!m
z+&|qzTt=*4z#k*yw|{d!`$ykF;V<@;>XCC(>?j3A`jQtsf;|0Okp1Z!<hRt@{8C;+
Wy_e+m(|h&vU+0N#dYzG%{r>?+6E@HQ

diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.cpp b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
index a096890..ed36644 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
@@ -1,10 +1,146 @@
 #include "abr.h"
 #include <iostream>
+#include <cmath>
+#include <queue>
 
 ABR::ABR () {
 	head = nullptr;
+	count = 0;
+	deep = 0;
 }
 
 ABR::~ABR () {
 
-}
\ No newline at end of file
+}
+
+bool ABR::isEmpty() const { return count == 0; }
+
+unsigned int ABR::draw_node(const Node* n, unsigned int length) const {
+	if (n) {
+		unsigned int mid;
+		if (length%2 == 0) mid = length/2;
+		else mid = length/2 +1;
+
+		unsigned int left;
+		if (mid%2 == 0) left = mid/2;
+		else left = mid/2 +1;
+
+		unsigned int right = mid+left;
+
+		unsigned int curr_col = 0;
+
+		// On dessine la ligne avec l'element n->element au milieu
+		for(++curr_col; curr_col<left; ++curr_col)
+			std::cout << " ";
+
+		if (n->left) {
+			std::cout << "┌";
+			for(++curr_col; curr_col<mid; ++curr_col) std::cout << "─";
+		}
+		else {
+			std::cout << " ";
+			for(++curr_col; curr_col<mid; ++curr_col)
+				std::cout << " ";
+		}
+
+		std::cout << n->element;
+
+		if (n->right) {
+			for(++curr_col; curr_col<right; ++curr_col) std::cout << "─";
+			std::cout << "┐";
+		}
+		else {
+			for(++curr_col; curr_col<right; ++curr_col)
+				std::cout << " ";
+			std::cout << " ";
+		}
+
+		for(++curr_col; curr_col<=length; ++curr_col)
+			std::cout << " ";
+
+		// On retourne la valeur decrementee, car la derniere iteration de la boucle for avait l'incrementee
+		return --curr_col;
+	}
+	else {
+		unsigned int curr_col = 0;
+
+		for(++curr_col; curr_col<=length; ++curr_col)
+			std::cout << " ";
+
+		return --curr_col;
+	}
+}
+
+void ABR::draw() const {
+	if (!isEmpty()) {
+
+		// On initialise les valeurs de depart pour construire le tableau d'affichage
+		unsigned int max_elems = pow(2,deep-1); // Nombre maximum d'elements sur le dernier niveau de l'ABR
+		unsigned int max_offset = max_elems-1; // Nombre d'espaces entre les noeuds sur le dernier niveau de l'ABR
+		unsigned int width = max_elems + max_offset; // Longeur de la grille d'affichage
+
+		std::cout << "deep : " << deep << std::endl;
+		std::cout << "max elements on last level : 2^(deep-1) = " << max_elems << std::endl << std::endl;
+
+		// On dessine les noeuds selon la grille d'affichage
+		unsigned int curr_col = 0;
+		unsigned int tab_width = width;
+
+		std::queue<const Node*> q;
+		q.push(head);
+
+		while (!q.empty()) {
+			curr_col += draw_node(q.front(), tab_width);
+
+			if (q.front()) {
+				if (q.front()->left) q.push(q.front()->left);
+				else q.push(nullptr);
+
+				if (q.front()->right) q.push(q.front()->right);
+				else q.push(nullptr);
+			}
+
+			q.pop();
+
+			// std::cout << "curr_col: " << curr_col;
+			// std::cout << " tab_width: " << tab_width;
+			// std::cout << " width: " << width << std::endl;
+
+			if (curr_col >= width) {
+				std::cout << std::endl;
+				curr_col = 0;
+				tab_width/=2;
+			}
+			else {
+				if (tab_width%2 != 0) {
+					++curr_col;
+					std::cout << " ";
+				}
+			}
+
+		}
+
+		// On affiche un saut de ligne a la fin de l'affichage de l'ABR
+		std::cout << std::endl;
+	}
+	else std::cout << "ABR est vide !" << std::endl;
+}
+
+void ABR::insert_from_node (const Elem& e, Node*& n) {
+	if (n == nullptr) {
+		n = new Node;
+		n->element = e;
+		n->left = nullptr;
+		n->right = nullptr;
+
+		++count;
+	}
+	else {
+		if (!n->left && !n->right) ++deep;
+
+		if (e < n->element) insert_from_node(e, n->left);
+		else if (e > n->element) insert_from_node(e, n->right);
+	}
+}
+
+void ABR::insert (const Elem& e) { insert_from_node(e, head); }
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
index 3cd0b24..6112ae8 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.h
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -9,8 +9,19 @@ struct Node {
 class ABR {
 	private:
 		Node* head;
+		unsigned int count;
+		unsigned int deep;
+
+		void insert_from_node (const Elem& e, Node*& n);
+		unsigned int draw_node(const Node* n, unsigned int length) const;
 
 	public:
 		ABR();
 		~ABR();
+
+		bool isEmpty() const;
+
+		void insert(const Elem& e);
+
+		void draw() const;
 };
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
index 7cee540..d9b26d9 100644
--- a/tp6/ArbreBinaireDeRecherche/src/main.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -1,7 +1,28 @@
 #include "abr.h"
+#include <queue>
+#include <iostream>
 
 int main() {
-  ABR a;
+    ABR a;
 
-  return 0;
+    a.insert(6);
+    a.insert(3);
+    a.insert(9);
+    a.insert(8);
+    a.insert(4);
+    a.insert(2);
+    a.insert(10);
+    a.insert(11);
+    a.insert(7);
+    a.insert(1);
+
+    a.draw();
+
+    // std::queue<int*> q;
+    // q.push(nullptr);
+    // if (!q.front()) {
+    //     std::cout << "nullptr!" << std::endl;
+    // }
+
+    return 0;
 }
-- 
GitLab


From a9c20f9d1fc1a8a193a01e88b832cd2393e835ee Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 26 Oct 2020 19:16:47 +0100
Subject: [PATCH 08/23] Draw function improved

- works great with numbers that contain 1 digit
- fixed 'depth' bug
- bug with numbers that contain >1 digits
---
 tp6/ArbreBinaireDeRecherche/src/abr.cpp  | 144 ++++++++++++++++-------
 tp6/ArbreBinaireDeRecherche/src/abr.h    |  25 +++-
 tp6/ArbreBinaireDeRecherche/src/main.cpp |  22 +++-
 3 files changed, 146 insertions(+), 45 deletions(-)

diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.cpp b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
index ed36644..8edc0a9 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
@@ -6,60 +6,84 @@
 ABR::ABR () {
 	head = nullptr;
 	count = 0;
-	deep = 0;
 }
 
 ABR::~ABR () {
 
 }
 
+Node* ABR::get_head() const { return head; }
+
 bool ABR::isEmpty() const { return count == 0; }
 
+unsigned int ABR::get_depth_from_node(Node* n, unsigned int depth_count) const {
+	if (n) {
+		++depth_count;
+
+		if (n->left && n->right) {
+			unsigned int left = get_depth_from_node(n->left, depth_count);
+			unsigned int right = get_depth_from_node(n->right, depth_count);
+
+			if (left > right) return left;
+			return right;
+		}
+		else {
+			if (n->left) return get_depth_from_node(n->left, depth_count);
+			if (n->right) return get_depth_from_node(n->right, depth_count);
+		}
+	}
+	return depth_count;
+}
+
+unsigned int ABR::get_depth() const { return get_depth_from_node(head, 0); }
+
 unsigned int ABR::draw_node(const Node* n, unsigned int length) const {
 	if (n) {
-		unsigned int mid;
-		if (length%2 == 0) mid = length/2;
-		else mid = length/2 +1;
+		unsigned int mid = length/2;
+		if (length%2 != 0) ++mid;
 
-		unsigned int left;
-		if (mid%2 == 0) left = mid/2;
-		else left = mid/2 +1;
+		unsigned int left = mid/2;
+		if (mid%2 != 0) ++left;
 
 		unsigned int right = mid+left;
 
-		unsigned int curr_col = 0;
-
 		// On dessine la ligne avec l'element n->element au milieu
-		for(++curr_col; curr_col<left; ++curr_col)
-			std::cout << " ";
-
-		if (n->left) {
-			std::cout << "┌";
-			for(++curr_col; curr_col<mid; ++curr_col) std::cout << "─";
-		}
-		else {
-			std::cout << " ";
-			for(++curr_col; curr_col<mid; ++curr_col)
+		unsigned int curr_col = 0;
+		// Si la longeur est 1, alors on est sur le dernier niveau
+		// => donc on n'affiche pas les espaces et fleches
+		if (length != 1) {
+			for(++curr_col; curr_col<left; ++curr_col)
 				std::cout << " ";
+
+			if (n->left) {
+				std::cout << "┌";
+				for(++curr_col; curr_col<mid; ++curr_col) std::cout << "─";
+			}
+			else {
+				for(; curr_col<mid; ++curr_col)
+					std::cout << " ";
+			}
 		}
 
 		std::cout << n->element;
 
-		if (n->right) {
-			for(++curr_col; curr_col<right; ++curr_col) std::cout << "─";
-			std::cout << "┐";
-		}
-		else {
-			for(++curr_col; curr_col<right; ++curr_col)
+		// Si la longeur est 1, alors on est sur le dernier niveau
+		// => donc on n'affiche pas les espaces et fleches
+		if (length != 1) {
+			if (n->right) {
+				for(++curr_col; curr_col<right; ++curr_col) std::cout << "─";
+				std::cout << "┐";
+			}
+			else {
+				for(; curr_col<right; ++curr_col)
+					std::cout << " ";
+			}
+
+			for(++curr_col; curr_col<=length; ++curr_col)
 				std::cout << " ";
-			std::cout << " ";
 		}
 
-		for(++curr_col; curr_col<=length; ++curr_col)
-			std::cout << " ";
-
-		// On retourne la valeur decrementee, car la derniere iteration de la boucle for avait l'incrementee
-		return --curr_col;
+		return length;
 	}
 	else {
 		unsigned int curr_col = 0;
@@ -67,54 +91,75 @@ unsigned int ABR::draw_node(const Node* n, unsigned int length) const {
 		for(++curr_col; curr_col<=length; ++curr_col)
 			std::cout << " ";
 
+		// On retourne la valeur decrementee, car la derniere iteration de la boucle for avait l'incrementee
 		return --curr_col;
 	}
 }
 
-void ABR::draw() const {
+void ABR::draw_from_node(const Node* n) const {
 	if (!isEmpty()) {
 
 		// On initialise les valeurs de depart pour construire le tableau d'affichage
-		unsigned int max_elems = pow(2,deep-1); // Nombre maximum d'elements sur le dernier niveau de l'ABR
+		unsigned int depth = get_depth();
+		unsigned int max_elems = pow(2,depth-1); // Nombre maximum d'elements sur le dernier niveau de l'ABR
 		unsigned int max_offset = max_elems-1; // Nombre d'espaces entre les noeuds sur le dernier niveau de l'ABR
 		unsigned int width = max_elems + max_offset; // Longeur de la grille d'affichage
 
-		std::cout << "deep : " << deep << std::endl;
-		std::cout << "max elements on last level : 2^(deep-1) = " << max_elems << std::endl << std::endl;
+		std::cout << "count : " << count << std::endl;
+		std::cout << "depth : " << depth << std::endl;
+		std::cout << "max elements on last level : 2^(depth-1) = " << max_elems << std::endl << std::endl;
 
 		// On dessine les noeuds selon la grille d'affichage
 		unsigned int curr_col = 0;
 		unsigned int tab_width = width;
 
 		std::queue<const Node*> q;
-		q.push(head);
+		q.push(n);
 
 		while (!q.empty()) {
+			// On dessine le noeud actuel et on sauvegarde la colonne ou on s'est arrete
 			curr_col += draw_node(q.front(), tab_width);
 
+			// On se prepare pour la prochaine iteration.
+			// Si le pointeur sur le noeud actuel n'est pas NULL, alors
 			if (q.front()) {
+				// Si le noeud actuel possede un fils gauche,
+				//  alors on enfile un pointeur vers son fils gauche
+				// sinon on enfile un pointeur null
 				if (q.front()->left) q.push(q.front()->left);
 				else q.push(nullptr);
 
+				// Si le noeud actuel possede un fils droit,
+				//  alors on enfile un pointeur vers son fils droit
+				// sinon on enfile un pointeur null
 				if (q.front()->right) q.push(q.front()->right);
 				else q.push(nullptr);
 			}
 
+			// On defile le pointeur vers le noeud actuel,
+			// car on en a plus besoin (deja dessine)
 			q.pop();
 
 			// std::cout << "curr_col: " << curr_col;
 			// std::cout << " tab_width: " << tab_width;
 			// std::cout << " width: " << width << std::endl;
 
+			// Si on a atteint la fin de la table d'affichage, alors
+			// on affiche un saut de ligne et on remet la colonne actuelle a 0,
+			// et on divise aussi la largeur de la ligne actuelle par 2.
 			if (curr_col >= width) {
 				std::cout << std::endl;
 				curr_col = 0;
-				tab_width/=2;
+				tab_width/=2; // Largeur de la prochaine ligne a dessiner sera 2 fois plus petite
 			}
+			// Si on a pas encore atteint la fin de la table d'affichage
 			else {
+				// Si la largeur de la ligne actuelle est impaire,
+				// on dessine un espace, car la colonne est represente par 'int'
+				// (ex. 15/7=2 => il nous manque un espace a dessiner)
 				if (tab_width%2 != 0) {
-					++curr_col;
 					std::cout << " ";
+					++curr_col;
 				}
 			}
 
@@ -126,6 +171,8 @@ void ABR::draw() const {
 	else std::cout << "ABR est vide !" << std::endl;
 }
 
+void ABR::draw() const { draw_from_node(head); }
+
 void ABR::insert_from_node (const Elem& e, Node*& n) {
 	if (n == nullptr) {
 		n = new Node;
@@ -136,11 +183,24 @@ void ABR::insert_from_node (const Elem& e, Node*& n) {
 		++count;
 	}
 	else {
-		if (!n->left && !n->right) ++deep;
+		if (e != n->element) {
+			if (e < n->element) insert_from_node(e, n->left);
+			else insert_from_node(e, n->right);
+		}
+	}
+}
+
+void ABR::insert (const Elem& e) { insert_from_node(e, head); }
 
-		if (e < n->element) insert_from_node(e, n->left);
-		else if (e > n->element) insert_from_node(e, n->right);
+Node* ABR::find_from_node(const Elem& e, Node* n) const {
+	if (n) {
+		if (e == n->element) return n;
+		else {
+			if (e < n->element) return find_from_node(e, n->left);
+			else return find_from_node(e, n->right);
+		}
 	}
+	return nullptr;
 }
 
-void ABR::insert (const Elem& e) { insert_from_node(e, head); }
\ No newline at end of file
+Node* ABR::find(const Elem& e) const { return find_from_node(e, head); }
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
index 6112ae8..8877529 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.h
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -10,18 +10,41 @@ class ABR {
 	private:
 		Node* head;
 		unsigned int count;
-		unsigned int deep;
 
+		// Postcondition: Commence son chemin a partir d'un noeud n
+		//				  e est apres insere dans un bon endroit
 		void insert_from_node (const Elem& e, Node*& n);
+
+		// Preconditions: length = la longeur de la ligne a dessiner
+		// Postcondition: Dessine UNE ligne avec un noeud (element) au milieu
+		// Resultat: Retourne la colonne sur la-quelle on s'est arrete apres l'affichage d'un noeud
 		unsigned int draw_node(const Node* n, unsigned int length) const;
 
 	public:
 		ABR();
 		~ABR();
 
+		Node* get_head() const;
+
 		bool isEmpty() const;
 
+		// Postcondition: Si e n'est pas present dans l'ABR,
+		//				  alors un noeud avec l'element e dedans est insere dans l'ABR
+		//				  Si e est deja present, alors ne fait rien
 		void insert(const Elem& e);
 
+		// Postcondition: Si l'ABR n'est pas vide, dessine l'ABR entier
+		//				  (parcours en largeur, cad niveau apres niveau)
+		//				  Si l'ABR est vide, alors affiche une chaine de caracteres
 		void draw() const;
+
+		void draw_from_node(const Node* n) const;
+
+		Node* find(const Elem& e) const;
+
+		Node* find_from_node(const Elem& e, Node* n) const;
+
+		unsigned int get_depth() const;
+
+		unsigned int get_depth_from_node(Node* n, unsigned int depth_count) const;
 };
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
index d9b26d9..3c8d912 100644
--- a/tp6/ArbreBinaireDeRecherche/src/main.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -12,12 +12,30 @@ int main() {
     a.insert(4);
     a.insert(2);
     a.insert(10);
-    a.insert(11);
-    a.insert(7);
+    a.insert(5);
     a.insert(1);
+    a.insert(7);
+    a.insert(11);
+
+    // a.insert(50);
+    // a.insert(60);
+    // a.insert(40);
+    // a.insert(30);
+    // a.insert(45);
+    // a.insert(55);
+    // a.insert(65);
 
     a.draw();
 
+    // a.draw_from_node(a.get_head()->right);
+
+    // Node* n = a.find(11);
+    // if (n) {
+    //     std::cout << "OK" << std::endl;
+    //     std::cout << n->element << std::endl;
+    // }
+    // else std::cout << "NOPE" << std::endl;
+
     // std::queue<int*> q;
     // q.push(nullptr);
     // if (!q.front()) {
-- 
GitLab


From dc7e5e4ce8cb4334fd759000b8f15a13da454c6b Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 26 Oct 2020 22:13:28 +0100
Subject: [PATCH 09/23] Added 3 Orders of Listing (with handler function)

- Infix, Prefix and Postfix orders
- Can be used with custom handler function (by passing a function pointer as argument), default function displays each element
---
 tp6/ArbreBinaireDeRecherche/src/abr.cpp  | 58 +++++++++++++++++++++---
 tp6/ArbreBinaireDeRecherche/src/abr.h    | 12 +++--
 tp6/ArbreBinaireDeRecherche/src/main.cpp | 18 ++++----
 3 files changed, 70 insertions(+), 18 deletions(-)

diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.cpp b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
index 8edc0a9..f0a2848 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
@@ -3,6 +3,9 @@
 #include <cmath>
 #include <queue>
 
+// Fonction de traitement des noeuds par defaut (utilisee dans la fonction 'parcours')
+void list_elements(Node* n) { std::cout << n->element << " "; }
+
 ABR::ABR () {
 	head = nullptr;
 	count = 0;
@@ -35,7 +38,7 @@ unsigned int ABR::get_depth_from_node(Node* n, unsigned int depth_count) const {
 	return depth_count;
 }
 
-unsigned int ABR::get_depth() const { return get_depth_from_node(head, 0); }
+unsigned int ABR::get_depth() const { return get_depth_from_node(head); }
 
 unsigned int ABR::draw_node(const Node* n, unsigned int length) const {
 	if (n) {
@@ -96,7 +99,7 @@ unsigned int ABR::draw_node(const Node* n, unsigned int length) const {
 	}
 }
 
-void ABR::draw_from_node(const Node* n) const {
+void ABR::draw_from_node(const Node* n, bool extra) const {
 	if (!isEmpty()) {
 
 		// On initialise les valeurs de depart pour construire le tableau d'affichage
@@ -105,9 +108,11 @@ void ABR::draw_from_node(const Node* n) const {
 		unsigned int max_offset = max_elems-1; // Nombre d'espaces entre les noeuds sur le dernier niveau de l'ABR
 		unsigned int width = max_elems + max_offset; // Longeur de la grille d'affichage
 
-		std::cout << "count : " << count << std::endl;
-		std::cout << "depth : " << depth << std::endl;
-		std::cout << "max elements on last level : 2^(depth-1) = " << max_elems << std::endl << std::endl;
+		if (extra) {
+			std::cout << "Number of Elements         : " << count << std::endl;
+			std::cout << "Depth (Number of Levels)   : " << depth << std::endl;
+			std::cout << "Max Elements on Last Level : " << max_elems << std::endl << std::endl;
+		}
 
 		// On dessine les noeuds selon la grille d'affichage
 		unsigned int curr_col = 0;
@@ -171,7 +176,48 @@ void ABR::draw_from_node(const Node* n) const {
 	else std::cout << "ABR est vide !" << std::endl;
 }
 
-void ABR::draw() const { draw_from_node(head); }
+void ABR::draw(bool extra) const { draw_from_node(head, extra); }
+
+void ABR::parcours(void (*handler)(Node*)=list_elements, int mode) {
+	switch(mode) {
+		case 1: // Ordre PREFIX
+			parcours_prefix_from(head, handler);
+			std::cout << std::endl << std::endl;
+			break;
+		case 2: // Ordre POSTFIX
+			parcours_postfix_from(head, handler);
+			std::cout << std::endl << std::endl;
+			break;
+		default: // Ordre INFIX
+			parcours_infix_from(head, handler);
+			std::cout << std::endl << std::endl;
+			break;
+	}
+}
+
+void ABR::parcours_infix_from(Node* n, void (*handler)(Node*)=list_elements) {
+	if (n) {
+		parcours_infix_from(n->left, handler);
+		handler(n);
+		parcours_infix_from(n->right, handler);
+	}
+}
+
+void ABR::parcours_prefix_from(Node* n, void (*handler)(Node*)=list_elements) {
+	if (n) {
+		handler(n);
+		parcours_prefix_from(n->left, handler);
+		parcours_prefix_from(n->right, handler);
+	}
+}
+
+void ABR::parcours_postfix_from(Node* n, void (*handler)(Node*)=list_elements) {
+	if (n) {
+		parcours_postfix_from(n->left, handler);
+		parcours_postfix_from(n->right, handler);
+		handler(n);
+	}
+}
 
 void ABR::insert_from_node (const Elem& e, Node*& n) {
 	if (n == nullptr) {
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
index 8877529..57d1283 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.h
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -36,9 +36,15 @@ class ABR {
 		// Postcondition: Si l'ABR n'est pas vide, dessine l'ABR entier
 		//				  (parcours en largeur, cad niveau apres niveau)
 		//				  Si l'ABR est vide, alors affiche une chaine de caracteres
-		void draw() const;
+		void draw(bool extra=true) const;
 
-		void draw_from_node(const Node* n) const;
+		void draw_from_node(const Node* n, bool extra=true) const;
+
+		void parcours(void (*handler)(Node*), int mode=0);
+
+		void parcours_infix_from(Node* n, void (*handler)(Node*));
+		void parcours_prefix_from(Node* n, void (*handler)(Node*));
+		void parcours_postfix_from(Node* n, void (*handler)(Node*));
 
 		Node* find(const Elem& e) const;
 
@@ -46,5 +52,5 @@ class ABR {
 
 		unsigned int get_depth() const;
 
-		unsigned int get_depth_from_node(Node* n, unsigned int depth_count) const;
+		unsigned int get_depth_from_node(Node* n, unsigned int depth_count=0) const;
 };
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
index 3c8d912..cc37e6d 100644
--- a/tp6/ArbreBinaireDeRecherche/src/main.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -2,6 +2,11 @@
 #include <queue>
 #include <iostream>
 
+void mult_by_two(Node* n) {
+    n->element*=2;
+    std::cout << n->element << " ";
+}
+
 int main() {
     ABR a;
 
@@ -14,19 +19,14 @@ int main() {
     a.insert(10);
     a.insert(5);
     a.insert(1);
-    a.insert(7);
     a.insert(11);
 
-    // a.insert(50);
-    // a.insert(60);
-    // a.insert(40);
-    // a.insert(30);
-    // a.insert(45);
-    // a.insert(55);
-    // a.insert(65);
-
     a.draw();
 
+    a.parcours(mult_by_two, 1);
+
+    a.draw(false);
+
     // a.draw_from_node(a.get_head()->right);
 
     // Node* n = a.find(11);
-- 
GitLab


From aa00bb9d3c1d6fd8a338032c6334945a7d8de658 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 27 Oct 2020 12:18:34 +0100
Subject: [PATCH 10/23] Parcours Function Updated

- changed handler parameters default value
- added #ifndef
---
 tp6/ArbreBinaireDeRecherche/src/abr.cpp  |  8 ++++----
 tp6/ArbreBinaireDeRecherche/src/abr.h    | 19 ++++++++++++++-----
 tp6/ArbreBinaireDeRecherche/src/main.cpp |  2 +-
 3 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.cpp b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
index f0a2848..5c4adb7 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
@@ -178,7 +178,7 @@ void ABR::draw_from_node(const Node* n, bool extra) const {
 
 void ABR::draw(bool extra) const { draw_from_node(head, extra); }
 
-void ABR::parcours(void (*handler)(Node*)=list_elements, int mode) {
+void ABR::parcours(void (*handler)(Node*), int mode) {
 	switch(mode) {
 		case 1: // Ordre PREFIX
 			parcours_prefix_from(head, handler);
@@ -195,7 +195,7 @@ void ABR::parcours(void (*handler)(Node*)=list_elements, int mode) {
 	}
 }
 
-void ABR::parcours_infix_from(Node* n, void (*handler)(Node*)=list_elements) {
+void ABR::parcours_infix_from(Node* n, void (*handler)(Node*)) {
 	if (n) {
 		parcours_infix_from(n->left, handler);
 		handler(n);
@@ -203,7 +203,7 @@ void ABR::parcours_infix_from(Node* n, void (*handler)(Node*)=list_elements) {
 	}
 }
 
-void ABR::parcours_prefix_from(Node* n, void (*handler)(Node*)=list_elements) {
+void ABR::parcours_prefix_from(Node* n, void (*handler)(Node*)) {
 	if (n) {
 		handler(n);
 		parcours_prefix_from(n->left, handler);
@@ -211,7 +211,7 @@ void ABR::parcours_prefix_from(Node* n, void (*handler)(Node*)=list_elements) {
 	}
 }
 
-void ABR::parcours_postfix_from(Node* n, void (*handler)(Node*)=list_elements) {
+void ABR::parcours_postfix_from(Node* n, void (*handler)(Node*)) {
 	if (n) {
 		parcours_postfix_from(n->left, handler);
 		parcours_postfix_from(n->right, handler);
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
index 57d1283..06792dd 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.h
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -1,5 +1,12 @@
+#ifndef _ABR
+#define _ABR
+
 #include "element.h"
 
+struct Node;
+// Fonction de traitement des noeuds par defaut (utilisee dans la fonction membre 'parcours')
+void list_elements(Node* n);
+
 struct Node {
 	Elem element;
 	Node* left;
@@ -40,11 +47,11 @@ class ABR {
 
 		void draw_from_node(const Node* n, bool extra=true) const;
 
-		void parcours(void (*handler)(Node*), int mode=0);
+		void parcours(void (*handler)(Node*)=list_elements, int mode=0);
 
-		void parcours_infix_from(Node* n, void (*handler)(Node*));
-		void parcours_prefix_from(Node* n, void (*handler)(Node*));
-		void parcours_postfix_from(Node* n, void (*handler)(Node*));
+		void parcours_infix_from(Node* n, void (*handler)(Node*)=list_elements);
+		void parcours_prefix_from(Node* n, void (*handler)(Node*)=list_elements);
+		void parcours_postfix_from(Node* n, void (*handler)(Node*)=list_elements);
 
 		Node* find(const Elem& e) const;
 
@@ -53,4 +60,6 @@ class ABR {
 		unsigned int get_depth() const;
 
 		unsigned int get_depth_from_node(Node* n, unsigned int depth_count=0) const;
-};
\ No newline at end of file
+};
+
+#endif
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
index cc37e6d..1936d91 100644
--- a/tp6/ArbreBinaireDeRecherche/src/main.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -23,7 +23,7 @@ int main() {
 
     a.draw();
 
-    a.parcours(mult_by_two, 1);
+    a.parcours(mult_by_two);
 
     a.draw(false);
 
-- 
GitLab


From d7a4af01158cfc2943e9069a5b36c693f7bdd1fe Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 28 Oct 2020 23:34:23 +0100
Subject: [PATCH 11/23] Implemented all functions

- still some bugs with draw
- documentation missing
- everything else works good
- TODO may be 'equalize' function
---
 tp6/ArbreBinaireDeRecherche/src/abr.cpp  | 118 ++++++++++++++++++++++-
 tp6/ArbreBinaireDeRecherche/src/abr.h    |  26 +++--
 tp6/ArbreBinaireDeRecherche/src/main.cpp |  81 +++++++++++++---
 3 files changed, 201 insertions(+), 24 deletions(-)

diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.cpp b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
index 5c4adb7..546bddc 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.cpp
@@ -4,17 +4,53 @@
 #include <queue>
 
 // Fonction de traitement des noeuds par defaut (utilisee dans la fonction 'parcours')
-void list_elements(Node* n) { std::cout << n->element << " "; }
+void ABR::list_elements(Node* n) { std::cout << n->element << " "; }
+
+void destruct(Node* n) {
+	delete n;
+	n = nullptr;
+}
 
 ABR::ABR () {
 	head = nullptr;
 	count = 0;
 }
 
-ABR::~ABR () {
+void ABR::copy_from_node(const Node* n) {
+	std::queue<const Node*> q;
+	q.push(n);
+
+	while (!q.empty()) {
+		this->insert(q.front()->element);
+
+		if (q.front()) {
+			if (q.front()->left) q.push(q.front()->left);
+			if (q.front()->right) q.push(q.front()->right);
+		}
+
+		q.pop();
+	}
+}
+
+ABR::ABR(const ABR& a) {
+	head = nullptr;
+	count = 0;
+	copy_from_node(a.head);
+}
 
+ABR& ABR::operator=(const ABR& a) {
+	if (this->isEmpty()) copy_from_node(a.head);
+	else {
+		this->parcours_postfix_from(head, destruct);
+		this->head = nullptr;
+		this->count = 0;
+		copy_from_node(a.head);
+	}
+	return *this;
 }
 
+ABR::~ABR () { parcours_postfix_from(head, destruct); }
+
 Node* ABR::get_head() const { return head; }
 
 bool ABR::isEmpty() const { return count == 0; }
@@ -178,7 +214,7 @@ void ABR::draw_from_node(const Node* n, bool extra) const {
 
 void ABR::draw(bool extra) const { draw_from_node(head, extra); }
 
-void ABR::parcours(void (*handler)(Node*), int mode) {
+void ABR::parcours(int mode, void (*handler)(Node*)) {
 	switch(mode) {
 		case 1: // Ordre PREFIX
 			parcours_prefix_from(head, handler);
@@ -238,6 +274,82 @@ void ABR::insert_from_node (const Elem& e, Node*& n) {
 
 void ABR::insert (const Elem& e) { insert_from_node(e, head); }
 
+Node* ABR::get_parent_from_node(const Elem& e, Node* n, Node* parent) const {
+	if (n) {
+		if (n->element == e) return parent;
+		else {
+			if (e < n->element) return get_parent_from_node(e, n->left, n);
+			else return get_parent_from_node(e, n->right, n);
+		}
+	}
+	return nullptr;
+}
+
+Node* ABR::get_parent(const Elem& e) const { return get_parent_from_node(e, head); }
+
+void ABR::remove(const Elem& e) {
+	Node* parent = get_parent(e);
+	Node* n = find(e);
+
+	if (n) {
+		if (n->left && n->right) {
+			Node* temp = n->left;
+
+			while(temp->right != nullptr) {
+				temp = temp->right;
+			}
+
+			Node* parent_temp = get_parent(temp->element);
+			if (parent_temp == n) parent_temp->left = temp->left;
+			else parent_temp->right = nullptr;
+
+			temp->left = n->left;
+			temp->right = n->right;
+
+			if (parent) {
+				if (parent->left == n) parent->left=temp;
+				else parent->right=temp;
+			}
+			else head = temp;
+
+			delete n;
+			n = nullptr;
+		}
+		else if (n->left) {
+			if (parent) {
+				if (parent->left == n) parent->left=n->left;
+				else parent->right=n->left;
+			}
+			else head = n->left;
+
+			delete n;
+			n = nullptr;
+		}
+		else if (n->right) {
+			if (parent) {
+				if (parent->left == n) parent->left=n->right;
+				else parent->right=n->right;
+			}
+			else head = n->right;
+
+			delete n;
+			n = nullptr;
+		}
+		else {
+			if (parent) {
+				if (parent->left == n) parent->left=nullptr;
+				else parent->right=nullptr;
+			}
+			else head = n;
+
+			delete n;
+			n = nullptr;
+		}
+
+		--count;
+	}
+}
+
 Node* ABR::find_from_node(const Elem& e, Node* n) const {
 	if (n) {
 		if (e == n->element) return n;
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
index 06792dd..f91c0f5 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.h
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -3,10 +3,6 @@
 
 #include "element.h"
 
-struct Node;
-// Fonction de traitement des noeuds par defaut (utilisee dans la fonction membre 'parcours')
-void list_elements(Node* n);
-
 struct Node {
 	Elem element;
 	Node* left;
@@ -27,8 +23,16 @@ class ABR {
 		// Resultat: Retourne la colonne sur la-quelle on s'est arrete apres l'affichage d'un noeud
 		unsigned int draw_node(const Node* n, unsigned int length) const;
 
+		// Fonction de traitement des noeuds par defaut (utilisee dans la fonction membre 'parcours')
+		static void list_elements(Node* n);
+
+		void copy_from_node(const Node* n);
+
 	public:
 		ABR();
+
+		ABR(const ABR& a);
+
 		~ABR();
 
 		Node* get_head() const;
@@ -40,14 +44,16 @@ class ABR {
 		//				  Si e est deja present, alors ne fait rien
 		void insert(const Elem& e);
 
+		void remove(const Elem& e);
+
 		// Postcondition: Si l'ABR n'est pas vide, dessine l'ABR entier
 		//				  (parcours en largeur, cad niveau apres niveau)
 		//				  Si l'ABR est vide, alors affiche une chaine de caracteres
-		void draw(bool extra=true) const;
+		void draw(bool extra=false) const;
 
-		void draw_from_node(const Node* n, bool extra=true) const;
+		void draw_from_node(const Node* n, bool extra=false) const;
 
-		void parcours(void (*handler)(Node*)=list_elements, int mode=0);
+		void parcours(int mode, void (*handler)(Node*)=list_elements);
 
 		void parcours_infix_from(Node* n, void (*handler)(Node*)=list_elements);
 		void parcours_prefix_from(Node* n, void (*handler)(Node*)=list_elements);
@@ -57,9 +63,15 @@ class ABR {
 
 		Node* find_from_node(const Elem& e, Node* n) const;
 
+		Node* get_parent(const Elem& e) const;
+
+		Node* get_parent_from_node(const Elem& e, Node* n, Node* parent=nullptr) const;
+
 		unsigned int get_depth() const;
 
 		unsigned int get_depth_from_node(Node* n, unsigned int depth_count=0) const;
+
+		ABR& operator=(const ABR& a);
 };
 
 #endif
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
index 1936d91..e4e147c 100644
--- a/tp6/ArbreBinaireDeRecherche/src/main.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -21,26 +21,79 @@ int main() {
     a.insert(1);
     a.insert(11);
 
+    std::cout << " *** Affichage avec extra informations ***" << std::endl;
+    a.draw(true);
+
+    std::cout << " *** Differents parcours de l'ABR (fonction d'affichage par defaut) ***" << std::endl;
+    std::cout << "Parcours INFIX : " << std::endl;
+    a.parcours(0);
+
+    std::cout << "Parcours PREFIX : " << std::endl;
+    a.parcours(1);
+
+    std::cout << "Parcours POSTFIX : " << std::endl;
+    a.parcours(2);
+
+    std::cout << "Parcours PREFIX (MULTIPLICATION par 2) : " << std::endl;
+    a.parcours(1, mult_by_two);
+
+    std::cout << " *** Affichage sans extra informations (comportement par defaut) ***" << std::endl;
     a.draw();
 
-    a.parcours(mult_by_two);
+    std::cout << " *** Affichage a partir du fils gauche ***" << std::endl;
+    a.draw_from_node(a.get_head()->left);
+
+    std::cout << " *** Recherche de l'element 6 ***" << std::endl;
+    Node* n = a.find(6);
+    if (n) {
+        std::cout << "Element found : ";
+        std::cout << n->element << std::endl << std::endl;
+    }
+    else std::cout << "Element not found" << std::endl << std::endl;
+
+    std::cout << " *** Creation d'ABR par copie ***" << std::endl;
+    ABR b(a);
+    b.draw(true);
+
+    std::cout << " *** Affectation d'ABR ***" << std::endl;
+    std::cout << "Creation de c et d ..." << std::endl;
+    std::cout << "Affectation d = c = b ..." << std::endl;
+    ABR c,d;
+    d = c = b;
+
+    std::cout << "Insertion de 24 dans b ..." << std::endl;
+    b.insert(24);
+    std::cout << "Insertion de 14 dans c ..." << std::endl;
+    c.insert(14);
+
+    std::cout << "b:" << std::endl;
+    b.draw(true);
+    std::cout << "c:" << std::endl;
+    c.draw(true);
+    std::cout << "d:" << std::endl;
+    d.draw(true);
+
+    std::cout << " *** Suppression d'un element ***" << std::endl;
+    std::cout << "12 dans d:" << std::endl;
+    d.remove(12);
+    d.draw(true);
+
+    std::cout << "8 dans d:" << std::endl;
+    d.remove(8);
+    d.draw(true);
 
-    a.draw(false);
+    std::cout << "18 dans d:" << std::endl;
+    d.remove(18);
+    d.draw(true);
 
-    // a.draw_from_node(a.get_head()->right);
+    std::cout << "10 dans d:" << std::endl;
+    d.remove(10);
+    d.draw(true);
 
-    // Node* n = a.find(11);
-    // if (n) {
-    //     std::cout << "OK" << std::endl;
-    //     std::cout << n->element << std::endl;
-    // }
-    // else std::cout << "NOPE" << std::endl;
+    std::cout << "22 dans d:" << std::endl;
+    d.remove(22);
+    d.draw(true);
 
-    // std::queue<int*> q;
-    // q.push(nullptr);
-    // if (!q.front()) {
-    //     std::cout << "nullptr!" << std::endl;
-    // }
 
     return 0;
 }
-- 
GitLab


From e464751cb7212eba277a8d0b370b8209beabed09 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Wed, 28 Oct 2020 23:45:47 +0100
Subject: [PATCH 12/23] Minor File Organization Changes

- changed root folder name
---
 tp5/Table de Hachage/src/main.cpp             | 20 -------------------
 .../makefile                                  |  0
 .../src/hash_functions.cpp                    |  0
 .../src/key.h                                 |  0
 tp5/TableDeHachage/src/main.cpp               | 20 +++++++++++++++++++
 .../src/table.cpp                             |  0
 .../src/table.h                               |  0
 7 files changed, 20 insertions(+), 20 deletions(-)
 delete mode 100644 tp5/Table de Hachage/src/main.cpp
 rename tp5/{Table de Hachage => TableDeHachage}/makefile (100%)
 rename tp5/{Table de Hachage => TableDeHachage}/src/hash_functions.cpp (100%)
 rename tp5/{Table de Hachage => TableDeHachage}/src/key.h (100%)
 create mode 100644 tp5/TableDeHachage/src/main.cpp
 rename tp5/{Table de Hachage => TableDeHachage}/src/table.cpp (100%)
 rename tp5/{Table de Hachage => TableDeHachage}/src/table.h (100%)

diff --git a/tp5/Table de Hachage/src/main.cpp b/tp5/Table de Hachage/src/main.cpp
deleted file mode 100644
index 0268fab..0000000
--- a/tp5/Table de Hachage/src/main.cpp	
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "table.h"
-
-int main() {
-  Table t(10);
-
-  t.add(8);
-  t.add(2);
-  t.add(2);
-  t.add(2);
-  t.add(3);
-  t.add(7);
-  t.add(9);
-  t.add(4);
-  t.add(1);
-  t.add(6);
-
-  t.show();
-
-  return 0;
-}
diff --git a/tp5/Table de Hachage/makefile b/tp5/TableDeHachage/makefile
similarity index 100%
rename from tp5/Table de Hachage/makefile
rename to tp5/TableDeHachage/makefile
diff --git a/tp5/Table de Hachage/src/hash_functions.cpp b/tp5/TableDeHachage/src/hash_functions.cpp
similarity index 100%
rename from tp5/Table de Hachage/src/hash_functions.cpp
rename to tp5/TableDeHachage/src/hash_functions.cpp
diff --git a/tp5/Table de Hachage/src/key.h b/tp5/TableDeHachage/src/key.h
similarity index 100%
rename from tp5/Table de Hachage/src/key.h
rename to tp5/TableDeHachage/src/key.h
diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
new file mode 100644
index 0000000..cfdd90d
--- /dev/null
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -0,0 +1,20 @@
+#include "table.h"
+
+int main() {
+    Table t(10);
+
+    t.add(8);
+    t.add(2);
+    t.add(2);
+    t.add(2);
+    t.add(3);
+    t.add(7);
+    t.add(9);
+    t.add(4);
+    t.add(1);
+    t.add(6);
+
+    t.show();
+
+    return 0;
+}
diff --git a/tp5/Table de Hachage/src/table.cpp b/tp5/TableDeHachage/src/table.cpp
similarity index 100%
rename from tp5/Table de Hachage/src/table.cpp
rename to tp5/TableDeHachage/src/table.cpp
diff --git a/tp5/Table de Hachage/src/table.h b/tp5/TableDeHachage/src/table.h
similarity index 100%
rename from tp5/Table de Hachage/src/table.h
rename to tp5/TableDeHachage/src/table.h
-- 
GitLab


From fa5ba580495e8c7e7899bb54119f166c6cedf2fa Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Fri, 30 Oct 2020 12:09:32 +0100
Subject: [PATCH 13/23] Added Documentation

- Readme file
- Comments in header (.h) file
---
 tp6/ArbreBinaireDeRecherche/README.txt   | 71 ++++++++++++++++++
 tp6/ArbreBinaireDeRecherche/src/abr.h    | 96 +++++++++++++++++++-----
 tp6/ArbreBinaireDeRecherche/src/main.cpp | 31 ++++++++
 3 files changed, 181 insertions(+), 17 deletions(-)
 create mode 100644 tp6/ArbreBinaireDeRecherche/README.txt

diff --git a/tp6/ArbreBinaireDeRecherche/README.txt b/tp6/ArbreBinaireDeRecherche/README.txt
new file mode 100644
index 0000000..410d02e
--- /dev/null
+++ b/tp6/ArbreBinaireDeRecherche/README.txt
@@ -0,0 +1,71 @@
+================== Arbre Binaire de Recherche ==================
+Module realise par Eldar Kasmamytov
+
+
+===== Fonctionnalites presentes dans le module =====
+
+- Constructeur par copie (copie profonde)
+	Possibilite de faire une copie a partir d'un noeud 'n'.
+
+- Surcharge de l'operateur d'affectation (copie profonde)
+
+- Recherche d'un element
+
+- Insertion d'un element
+
+- Suppression d'un element
+	- Si le noeud est une feuille,
+	  alors le noeud est supprime simplement.
+	- Si le noeud possede un fils,
+	  alors le noeud est supprime, et son fils
+	  est rebranche au pere du noeud supprime.
+	- Si le noeud possede deux fils,
+	  alors le noeud est supprime et remplace par
+	  son plus proche predecesseur.
+
+- Parcours de l'arbre dans differents ordres:
+	- Ordre INFIX
+	- Ordre PREFIX (1)
+	- Ordre POSTFIX (2)
+	Fonction qui prend en parametre un pointeur de fonction 'handler',
+	qui est appele pour chaque element lors de parcours. Par defaut,
+	la fonction de traitement est 'list_elements' qui affiche les elements
+	dans l'ordre indique.
+	Par exemple, a est de type ABR.
+		Insertion des elements dans a dans l'ordre suivant:
+		6,3,9,8,4,2,10,5,1,11.
+
+		Appel a 'a.parcours(0)' (ordre INFIX):
+		1 2 3 4 5 6 8 9 10 11 
+
+		Appel a 'a.parcours(1)' (ordre PREFIX):
+		6 3 2 1 4 5 9 8 10 11 
+
+		Appel a 'a.parcours(2)' (ordre POSTFIX):
+		1 2 5 4 3 8 11 10 9 6 
+
+		Appel a 'a.parcours(1, mult_by_two)' (ordre PREFIX, fonction MULTIPLICATION par 2): 
+		12 6 4 2 8 10 18 16 20 22 
+		a est change.
+
+- Affichage de l'ABR entier ou d'un sous-ABR sous forme d'un arbre
+	(en utilisant parcours en largeur).
+	Possibilite d'afficher les informations supplementaires,
+	si le parametre 'extra' specifie.
+	Par exemple, a est de type ABR.
+		Insertion des elements dans a dans l'ordre suivant:
+		6,3,9,8,4,2,10,5,1,11.
+
+		Appel a 'a.draw(true)' affiche l'arbre suivant:
+			Number of Elements         : 10
+			Depth (Number of Levels)   : 4
+			Max Elements on Last Level : 8
+
+			   ┌───6───┐   
+			 ┌─3─┐   ┌─9─┐ 
+			┌2   4┐  8   10┐
+			1     5       11
+
+- Accesseur du premier noeud
+- Accesseur du pere d'un element
+- Accesseur de la profondeur de l'ABR (nombre de niveaux)
\ No newline at end of file
diff --git a/tp6/ArbreBinaireDeRecherche/src/abr.h b/tp6/ArbreBinaireDeRecherche/src/abr.h
index f91c0f5..e39d664 100644
--- a/tp6/ArbreBinaireDeRecherche/src/abr.h
+++ b/tp6/ArbreBinaireDeRecherche/src/abr.h
@@ -11,10 +11,10 @@ struct Node {
 
 class ABR {
 	private:
-		Node* head;
-		unsigned int count;
+		Node* head; // Pointeur vers le premier noeud
+		unsigned int count; // Nombre d'elements
 
-		// Postcondition: Commence son chemin a partir d'un noeud n
+		// Postcondition: Commence son chemin a partir d'un noeud n,
 		//				  e est apres insere dans un bon endroit
 		void insert_from_node (const Elem& e, Node*& n);
 
@@ -23,54 +23,116 @@ class ABR {
 		// Resultat: Retourne la colonne sur la-quelle on s'est arrete apres l'affichage d'un noeud
 		unsigned int draw_node(const Node* n, unsigned int length) const;
 
-		// Fonction de traitement des noeuds par defaut (utilisee dans la fonction membre 'parcours')
+		// Fonction de traitement des noeuds par defaut (utilisee dans la fonction membre 'parcours').
+		// Le mot cle 'static' est utilise, car la fonction 'parcours' exige une fonction 'handler', dont
+		// l'entete est 'void *nom* (Node*)', donc qui ne retourne aucune valeur et prend
+		// en parametre un seul argument de type 'Node*'. Si 'static' n'est pas utilise
+		// alors la fonction devient une fonction membre et donc prend en parametre
+		// un argument cache 'this', et en consequance elle ne correspond pas a 'handler'.
 		static void list_elements(Node* n);
 
-		void copy_from_node(const Node* n);
+		// Resultat: pareil que 'get_parent', sauf qu'il commence
+		//			 son chemin a partir du noeud n passe en parametre
+		Node* get_parent_from_node(const Elem& e, Node* n, Node* parent=nullptr) const;
+
+		// Resultat: retourne le nombre de niveaux dans l'ABR, mais
+		//			 commence son chemin a partir du noeud n passe en parametre
+		unsigned int get_depth_from_node(Node* n, unsigned int depth_count=0) const;
 
 	public:
+		// =========== Constructeurs ===========
+		// Constructeur par defaut
 		ABR();
 
+		// Constructeur par copie
+		// Postcondition: realise un copie profonde d'un arbre entier
 		ABR(const ABR& a);
 
+		// Destructeur
 		~ABR();
 
-		Node* get_head() const;
-
+		// =========== Fonctions Membres ===========
+		// Resultat: Retourne VRAI si l'ABR n'est pas vide,
+		//			 FAUX sinon
 		bool isEmpty() const;
 
-		// Postcondition: Si e n'est pas present dans l'ABR,
-		//				  alors un noeud avec l'element e dedans est insere dans l'ABR
-		//				  Si e est deja present, alors ne fait rien
+		// Postcondition: * Si e n'est pas present dans l'ABR,
+		//					alors un noeud avec l'element e dedans est insere dans l'ABR
+		//				  * Si e est deja present, alors ne fait rien
 		void insert(const Elem& e);
 
+		// Postcondition: Noeud contenant l'element e est supprime de l'ABR
+		//				  * Si le noeud est une feuille,
+		//					alors le noeud est supprime simplement
+		//				  * Si le noeud possede un fils,
+		//					alors le noeud est supprime, et son fils
+		//					est rebranche au pere du noeud supprime
+		//				  * Si le noeud possede deux fils,
+		//					alors le noeud est supprime et remplace par
+		//					son plus proche predecesseur
 		void remove(const Elem& e);
 
-		// Postcondition: Si l'ABR n'est pas vide, dessine l'ABR entier
-		//				  (parcours en largeur, cad niveau apres niveau)
-		//				  Si l'ABR est vide, alors affiche une chaine de caracteres
+		// Preconditions: extra: afficher ou pas les informations supplementaires
+		// Postcondition: * Si l'ABR n'est pas vide, dessine l'ABR entier
+		//					(parcours en largeur, cad niveau apres niveau)
+		//				  * Si l'ABR est vide, alors affiche une chaine de caracteres
 		void draw(bool extra=false) const;
 
+		// Preconditions: extra: afficher ou pas les informations supplementaires
+		// Postcondition: Pareil que 'draw', sauf qu'il commence a dessiner
+		//				  l'ABR a partir du noeud n passe en parametre
 		void draw_from_node(const Node* n, bool extra=false) const;
 
+		// Preconditions: * mode: 1=parcours PREFIX, 2=parcours POSTFIX, tout autre valeur=parcours INFIX
+		// 				  * handler: fonction dont l'entete est 'void *nom* (Node*)',
+		//					qui est appele pour chaque element dans l'ordre indique
+		// Postcondition: La fonction 'handler' est appliquee a chaque element
+		//				  de l'ABR dans l'ordre 'mode'
 		void parcours(int mode, void (*handler)(Node*)=list_elements);
 
+		// Preconditions: handler: fonction dont l'entete est 'void *nom* (Node*)',
+		//				  qui est appele pour chaque element dans l'ordre indique
+		// Postcondition: La fonction 'handler' est appliquee a chaque element
+		//				  a partir du noeud 'n' dans l'ordre INFIX 
 		void parcours_infix_from(Node* n, void (*handler)(Node*)=list_elements);
+
+		// Preconditions: handler: fonction dont l'entete est 'void *nom* (Node*)',
+		//				  qui est appele pour chaque element dans l'ordre indique
+		// Postcondition: La fonction 'handler' est appliquee a chaque element
+		//				  a partir du noeud 'n' dans l'ordre PREFIX 
 		void parcours_prefix_from(Node* n, void (*handler)(Node*)=list_elements);
+
+		// Preconditions: handler: fonction dont l'entete est 'void *nom* (Node*)',
+		//				  qui est appele pour chaque element dans l'ordre indique
+		// Postcondition: La fonction 'handler' est appliquee a chaque element
+		//				  a partir du noeud 'n' dans l'ordre POSTFIX 
 		void parcours_postfix_from(Node* n, void (*handler)(Node*)=list_elements);
 
+		// Resultat: * Si l'element e est present dans l'ABR,
+		//			   alors, retourne le noeud contenant l'element e
+		//			 * Sinon retourne un pointeur null
 		Node* find(const Elem& e) const;
 
+		// Resultat: Pareil que 'find', sauf qu'il commence
+		//			 son chemin a partir du noeud n passe en parametre
 		Node* find_from_node(const Elem& e, Node* n) const;
 
-		Node* get_parent(const Elem& e) const;
+		// Postcondition: Realise une copie profonde a partir du noeud n
+		void copy_from_node(const Node* n);
 
-		Node* get_parent_from_node(const Elem& e, Node* n, Node* parent=nullptr) const;
+		// =========== Accesseurs ===========
+		// Resultat: Premier Noeud de l'ABR
+		Node* get_head() const;
 
-		unsigned int get_depth() const;
+		// Resultat: retourne le pere de l'element e passe en parametre
+		Node* get_parent(const Elem& e) const;
 
-		unsigned int get_depth_from_node(Node* n, unsigned int depth_count=0) const;
+		// Resultat: retourne le nombre de niveaux dans l'ABR
+		unsigned int get_depth() const;
 
+		// =========== Surcharhes des operateurs ===========
+		// Postcondition: Realise une affectation (copie profonde)
+		// Resultat: Retourne l'adresse de l'ABR
 		ABR& operator=(const ABR& a);
 };
 
diff --git a/tp6/ArbreBinaireDeRecherche/src/main.cpp b/tp6/ArbreBinaireDeRecherche/src/main.cpp
index e4e147c..32e0962 100644
--- a/tp6/ArbreBinaireDeRecherche/src/main.cpp
+++ b/tp6/ArbreBinaireDeRecherche/src/main.cpp
@@ -1,13 +1,44 @@
 #include "abr.h"
 #include <queue>
 #include <iostream>
+#include <chrono>
 
 void mult_by_two(Node* n) {
     n->element*=2;
     std::cout << n->element << " ";
 }
 
+const unsigned int NB_ABR = 100;
+
 int main() {
+
+    // ABR tab[NB_ABR];
+    // Elem e;
+
+    // std::chrono::time_point<std::chrono::system_clock> start, end;
+    // start = std::chrono::system_clock::now();
+
+    // srand(time(NULL));
+
+    // for(unsigned int j=0; j<100; ++j) {
+    //     for (unsigned int i=0; i<NB_ABR; ++i) {
+    //         e = rand() % 1000;
+    //         tab[i].insert(e);
+    //     }
+    // }
+
+    // end = std::chrono::system_clock::now();
+    // int elapsed_microseconds
+    // = std::chrono::duration_cast<std::chrono::microseconds>(end-start).count();
+
+    // std::cout << "Elapsed Time : " << elapsed_microseconds << std::endl;
+
+    // int elapsed_time_for_one = elapsed_microseconds / NB_ABR;
+
+    // std::cout << "Elapsed For One : " << elapsed_time_for_one << std::endl;
+
+    // tab[1].parcours(0);
+
     ABR a;
 
     a.insert(6);
-- 
GitLab


From 07cb2db9a40672abb293fdd7ad1c2757ca49621a Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 2 Nov 2020 10:23:05 +0100
Subject: [PATCH 14/23] Added Info (template)

---
 tp5/TableDeHachage/makefile               | 11 ++-
 tp5/TableDeHachage/src/hash_functions.cpp | 14 ----
 tp5/TableDeHachage/src/info.cpp           |  1 +
 tp5/TableDeHachage/src/info.h             | 64 +++++++++++++++
 tp5/TableDeHachage/src/key.h              |  2 +-
 tp5/TableDeHachage/src/main.cpp           | 30 ++++---
 tp5/TableDeHachage/src/table.cpp          | 98 ++++++++++++-----------
 tp5/TableDeHachage/src/table.h            | 87 ++++++++++++++++++--
 8 files changed, 221 insertions(+), 86 deletions(-)
 delete mode 100644 tp5/TableDeHachage/src/hash_functions.cpp
 create mode 100644 tp5/TableDeHachage/src/info.cpp
 create mode 100644 tp5/TableDeHachage/src/info.h

diff --git a/tp5/TableDeHachage/makefile b/tp5/TableDeHachage/makefile
index 76416f2..edb678d 100644
--- a/tp5/TableDeHachage/makefile
+++ b/tp5/TableDeHachage/makefile
@@ -1,14 +1,17 @@
 all: bin/executable.out
 
-bin/executable.out: obj/main.o obj/table.o
-	g++ -Wall -g obj/main.o obj/table.o -o bin/executable.out
+bin/executable.out: obj/main.o obj/table.o obj/info.o
+	g++ -Wall -g obj/main.o obj/table.o obj/info.o -o bin/executable.out
 
-obj/main.o: src/main.cpp src/table.h src/key.h
+obj/main.o: src/main.cpp src/table.h src/key.h src/info.h
 	g++ -Wall -g -c src/main.cpp -o obj/main.o
 
-obj/table.o: src/table.h src/table.cpp src/key.h
+obj/table.o: src/table.h src/table.cpp src/key.h src/info.h
 	g++ -Wall -g -c src/table.cpp -o obj/table.o
 
+obj/info.o: src/info.h src/info.cpp
+	g++ -Wall -g -c src/info.cpp -o obj/info.o
+
 clean:
 	rm obj/*
 
diff --git a/tp5/TableDeHachage/src/hash_functions.cpp b/tp5/TableDeHachage/src/hash_functions.cpp
deleted file mode 100644
index e75ae99..0000000
--- a/tp5/TableDeHachage/src/hash_functions.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef _HASH_FUNCTIONS
-#define _HASH_FUNCTIONS
-
-#include "key.h"
-
-unsigned int hash_modulo (const Key& k, unsigned int size) {
-	return k % size;
-}
-
-unsigned int hash_skip_linear (const Key& k, unsigned int try_nb) {
-	return 1;
-}
-
-#endif
\ No newline at end of file
diff --git a/tp5/TableDeHachage/src/info.cpp b/tp5/TableDeHachage/src/info.cpp
new file mode 100644
index 0000000..4132463
--- /dev/null
+++ b/tp5/TableDeHachage/src/info.cpp
@@ -0,0 +1 @@
+#include "info.h"
\ No newline at end of file
diff --git a/tp5/TableDeHachage/src/info.h b/tp5/TableDeHachage/src/info.h
new file mode 100644
index 0000000..2795922
--- /dev/null
+++ b/tp5/TableDeHachage/src/info.h
@@ -0,0 +1,64 @@
+#ifndef _INFO
+#define _INFO
+
+#include <iostream>
+
+template<class T>
+class Info {
+	private:
+		T* value;
+
+	public:
+		Info();
+		Info(const T& value);
+		~Info();
+
+		T get() const;
+		void set(const T& value);
+
+		friend std::ostream& operator<<(std::ostream& output, const Info<T>& i) { 
+			output << *i.value;
+			return output;
+		}
+
+		friend std::istream& operator>>(std::istream& input, Info<T>& i) {
+			T temp;
+			input >> temp;
+			i.value = new T(temp);
+			return input;
+		}
+
+		Info<T>& operator=(const Info<T>& info);
+};
+
+template<class T>
+Info<T>::Info() { value = nullptr; }
+
+template<class T>
+Info<T>::Info(const T& value) { this->value = new T(value); }
+
+template<class T>
+Info<T>::~Info() {
+	if(value) {
+		delete value;
+		value = nullptr;
+	}
+}
+
+template<class T>
+T Info<T>::get() const { return *value; }
+
+template<class T>
+void Info<T>::set(const T& val) {
+	if (!this->value) this->value = new T(val);
+	else *this->value = val;
+}
+
+template<class T>
+Info<T>& Info<T>::operator=(const Info<T>& info) {
+	if (!this->value) this->value = new T(*info.value);
+	else *this->value = *info.value;
+	return *this;
+}
+
+#endif
diff --git a/tp5/TableDeHachage/src/key.h b/tp5/TableDeHachage/src/key.h
index cbe180a..f9dd454 100644
--- a/tp5/TableDeHachage/src/key.h
+++ b/tp5/TableDeHachage/src/key.h
@@ -1,6 +1,6 @@
 #ifndef _KEY
 #define _KEY
 
-typedef int Key;
+typedef unsigned int Key;
 
 #endif
diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
index cfdd90d..6f55977 100644
--- a/tp5/TableDeHachage/src/main.cpp
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -1,18 +1,26 @@
 #include "table.h"
+#include <iostream>
+#include <string>
+
+typedef Table<std::string> TableString;
+typedef Info<std::string> InfoString;
 
 int main() {
-    Table t(10);
+    TableString t(20);
+
+    InfoString i;
+    i = std::string("toto");
+
+    InfoString i2("mew");
+    
+    InfoString i3("tata");
+    i3 = std::string("nine");
 
-    t.add(8);
-    t.add(2);
-    t.add(2);
-    t.add(2);
-    t.add(3);
-    t.add(7);
-    t.add(9);
-    t.add(4);
-    t.add(1);
-    t.add(6);
+    t.add(8, i);
+    t.add(3, i);
+    t.add(2, i);
+    t.add(2, i2);
+    t.add(9, i3);
 
     t.show();
 
diff --git a/tp5/TableDeHachage/src/table.cpp b/tp5/TableDeHachage/src/table.cpp
index d01a369..e042f47 100644
--- a/tp5/TableDeHachage/src/table.cpp
+++ b/tp5/TableDeHachage/src/table.cpp
@@ -1,48 +1,50 @@
-#include "table.h"
-#include "hash_functions.cpp"
-#include <iostream>
-
-Table::Table (unsigned int size) {
-	max_elements = size;
-	nb_elements = 0;
-
-	elements = new Case[size];
-	hash = hash_modulo;
-	hash_step = hash_skip_linear;
-}
-
-Table::~Table () {
-	delete [] elements;
-}
-
-void Table::add (const Key& key) {
-	assert(nb_elements < max_elements);
-
-	unsigned int hash_code = hash(key, max_elements);
-	unsigned int try_nb = 1;
-
-	while(!elements[hash_code].free) {
-		hash_code += hash_step(key, try_nb++);
-		if(hash_code >= max_elements) {
-			hash_code = hash_code % max_elements;
-		}
-	}
-
-	if (elements[hash_code].free) {
-		elements[hash_code].key = key;
-		elements[hash_code].free = false;
-		++nb_elements;
-	}
-}
-
-void Table::show () const {
-	std::cout << "Maximum elements: " << max_elements << std::endl;
-	std::cout << "Elements stored: " << nb_elements << std::endl;
-	for(unsigned int i=0; i<max_elements; ++i) {
-		if(!elements[i].free) std::cout << "[" << elements[i].key << "]";
-		else std::cout << "[ ]";
-
-		if (i==max_elements-1) std::cout << std::endl;
-		else std::cout << "  ";
-	}
-}
\ No newline at end of file
+// #include "table.h"
+// #include <iostream>
+
+// unsigned int Table::hash_modulo (const Key& k, unsigned int size) { return k % size; }
+
+// unsigned int Table::rehash_linear (const Key& k, unsigned int try_nb) { return 1; }
+
+// Table::Table (unsigned int size, unsigned int (*hash)(const Key&, unsigned int))
+// 	: max_elements(size), nb_elements(0), hash(hash) {
+// 	elements = new Case[size];
+// 	rehash = rehash_linear;
+// }
+
+// Table::~Table () { delete [] elements; }
+
+// void Table::add (const Key& key) {
+// 	assert(nb_elements < max_elements);
+
+// 	unsigned int hash_code = hash(key, max_elements);
+// 	unsigned int try_nb = 1;
+
+// 	while(!elements[hash_code].free) {
+// 		hash_code += rehash(key, try_nb++);
+// 		if(hash_code >= max_elements) {
+// 			hash_code = hash_code % max_elements;
+// 		}
+// 	}
+
+// 	if (elements[hash_code].free) {
+// 		elements[hash_code].key = key;
+// 		elements[hash_code].free = false;
+// 		++nb_elements;
+// 	}
+// }
+
+// void Table::show () const {
+// 	std::cout << "Maximum elements: " << max_elements << std::endl;
+// 	std::cout << "Elements stored: " << nb_elements << std::endl;
+// 	for(unsigned int i=0; i<max_elements; ++i) {
+// 		if(!elements[i].free) std::cout << "[" << elements[i].key << "]";
+// 		else std::cout << "[ ]";
+
+// 		if (i==max_elements-1) std::cout << std::endl;
+// 		else std::cout << "  ";
+// 	}
+// }
+
+// void Table::set_hash(unsigned int (*hash)(const Key&, unsigned int)) { this->hash = hash; }
+
+// void Table::set_rehash(unsigned int (*rehash)(const Key&, unsigned int)) { this->rehash = rehash; }
\ No newline at end of file
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index 10c7633..04f8000 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -1,46 +1,117 @@
 #ifndef _TABLE
 #define _TABLE
 
-#include "key.h"
 #include <assert.h>
+#include "key.h"
+#include "info.h"
 
+template<class T>
 class Table;
 
+template<class T>
 class Case {
-	friend class Table;
+	friend class Table<T>;
 
 	private:
 		Key key;
+		Info<T> info;
 		bool free;
 
 	public:
 		Case() : free(true) {}
 		Case(const Key& k) : key(k), free(false) {}
 
-		void set(const Key& k) { key=k; free=false; }
-		Key get() const { return key; }
+		void set_key(const Key& k) { key=k; free=false; }
+		Key get_key() const { return key; }
 
 		bool isFree() const { return free; }
 };
 
+template<class T>
 class Table {
 	private:
-		Case* elements;
+		Case<T>* elements;
 
 		unsigned int max_elements;
 		unsigned int nb_elements;
 
 		unsigned int (*hash)(const Key&, unsigned int);
-		unsigned int (*hash_step)(const Key&, unsigned int);
+		unsigned int (*rehash)(const Key&, unsigned int);
+
+		static unsigned int hash_modulo (const Key& k, unsigned int size);
+		static unsigned int rehash_linear (const Key& k, unsigned int try_nb);
 
 	public:
-		Table(unsigned int size);
+		Table(unsigned int size, unsigned int (*hash)(const Key&, unsigned int)=hash_modulo);
 		~Table();
 
-		void add(const Key& e);
+		void set_hash(unsigned int (*hash)(const Key&, unsigned int));
+		void set_rehash(unsigned int (*rehash)(const Key&, unsigned int));
+
+		void add(const Key& e, const Info<T>& info);
 		void remove(unsigned int hash_code);
 		void show() const;
 
 };
 
+template<class T>
+unsigned int Table<T>::hash_modulo (const Key& k, unsigned int size) { return k % size; }
+
+template<class T>
+unsigned int Table<T>::rehash_linear (const Key& k, unsigned int try_nb) { return 1; }
+
+template<class T>
+Table<T>::Table (unsigned int size, unsigned int (*hash)(const Key&, unsigned int))
+	: max_elements(size), nb_elements(0), hash(hash) {
+	elements = new Case<T>[size];
+	rehash = rehash_linear;
+}
+
+template<class T>
+Table<T>::~Table () { delete [] elements; }
+
+template<class T>
+void Table<T>::add (const Key& key, const Info<T>& info) {
+	assert(nb_elements < max_elements);
+
+	unsigned int hash_code = hash(key, max_elements);
+	unsigned int try_nb = 1;
+
+	while(!elements[hash_code].free) {
+		hash_code += rehash(key, try_nb++);
+		if(hash_code >= max_elements) {
+			hash_code = hash_code % max_elements;
+		}
+	}
+
+	if (elements[hash_code].free) {
+		elements[hash_code].key = key;
+		elements[hash_code].info.set(info.get());
+		elements[hash_code].free = false;
+		++nb_elements;
+	}
+}
+
+template<class T>
+void Table<T>::show () const {
+	std::cout << "Maximum elements: " << max_elements << std::endl;
+	std::cout << "Elements stored: " << nb_elements << std::endl;
+	for(unsigned int i=0; i<max_elements; ++i) {
+		if(!elements[i].free) {
+			std::cout << "[" << elements[i].key << "->";
+			std::cout << elements[i].info << "]";
+		}
+		else std::cout << "[ ]";
+
+		if (i==max_elements-1) std::cout << std::endl;
+		else std::cout << "  ";
+	}
+}
+
+template<class T>
+void Table<T>::set_hash(unsigned int (*hash)(const Key&, unsigned int)) { this->hash = hash; }
+
+template<class T>
+void Table<T>::set_rehash(unsigned int (*rehash)(const Key&, unsigned int)) { this->rehash = rehash; }
+
 #endif
\ No newline at end of file
-- 
GitLab


From 8eda93861bd11f1ad1e9a94f465e0b0acf275688 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 2 Nov 2020 11:37:40 +0100
Subject: [PATCH 15/23] Key (template)

- add function overload
---
 tp5/TableDeHachage/src/key.h    | 60 ++++++++++++++++++++++-
 tp5/TableDeHachage/src/main.cpp | 30 +++++++-----
 tp5/TableDeHachage/src/table.h  | 87 +++++++++++++++++++--------------
 3 files changed, 126 insertions(+), 51 deletions(-)

diff --git a/tp5/TableDeHachage/src/key.h b/tp5/TableDeHachage/src/key.h
index f9dd454..57accf4 100644
--- a/tp5/TableDeHachage/src/key.h
+++ b/tp5/TableDeHachage/src/key.h
@@ -1,6 +1,64 @@
 #ifndef _KEY
 #define _KEY
 
-typedef unsigned int Key;
+#include <iostream>
+
+template<class T>
+class Key {
+	private:
+		T* value;
+
+	public:
+		Key();
+		Key(const T& value);
+		~Key();
+
+		T get() const;
+		void set(const T& value);
+
+		friend std::ostream& operator<<(std::ostream& output, const Key<T>& k) { 
+			output << *k.value;
+			return output;
+		}
+
+		friend std::istream& operator>>(std::istream& input, Key<T>& k) {
+			T temp;
+			input >> temp;
+			k.value = new T(temp);
+			return input;
+		}
+
+		Key<T>& operator=(const Key<T>& key);
+};
+
+template<class T>
+Key<T>::Key() { value = nullptr; }
+
+template<class T>
+Key<T>::Key(const T& value) { this->value = new T(value); }
+
+template<class T>
+Key<T>::~Key() {
+	if(value) {
+		delete value;
+		value = nullptr;
+	}
+}
+
+template<class T>
+T Key<T>::get() const { return *value; }
+
+template<class T>
+void Key<T>::set(const T& val) {
+	if (!this->value) this->value = new T(val);
+	else *this->value = val;
+}
+
+template<class T>
+Key<T>& Key<T>::operator=(const Key<T>& key) {
+	if (!this->value) this->value = new T(*key.value);
+	else *this->value = *key.value;
+	return *this;
+}
 
 #endif
diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
index 6f55977..8dd1548 100644
--- a/tp5/TableDeHachage/src/main.cpp
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -2,25 +2,31 @@
 #include <iostream>
 #include <string>
 
-typedef Table<std::string> TableString;
+typedef Table<unsigned int,std::string> Table_;
 typedef Info<std::string> InfoString;
+typedef Key<unsigned int> KeyInt;
 
 int main() {
-    TableString t(20);
+    Table_ t(20);
 
-    InfoString i;
-    i = std::string("toto");
+    // KeyInt k;
+    // k = 8;
+    // InfoString i;
+    // i = std::string("toto");
 
-    InfoString i2("mew");
+    // KeyInt k2(2);
+    // InfoString i2("mew");
     
-    InfoString i3("tata");
-    i3 = std::string("nine");
+    // KeyInt k3(234);
+    // k3 = 9;
+    // InfoString i3("tata");
+    // i3 = std::string("nine");
 
-    t.add(8, i);
-    t.add(3, i);
-    t.add(2, i);
-    t.add(2, i2);
-    t.add(9, i3);
+    t.add(8, std::string("toto"));
+    t.add(8, std::string("toto"));
+    t.add(2, std::string("toto"));
+    t.add(2, std::string("mew"));
+    t.add(9, std::string("nine"));
 
     t.show();
 
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index 04f8000..807861b 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -5,73 +5,75 @@
 #include "key.h"
 #include "info.h"
 
-template<class T>
+template<class K, class T>
 class Table;
 
-template<class T>
+template<class K, class T>
 class Case {
-	friend class Table<T>;
+	friend class Table<K,T>;
 
 	private:
-		Key key;
-		Info<T> info;
 		bool free;
 
 	public:
-		Case() : free(true) {}
-		Case(const Key& k) : key(k), free(false) {}
+		Key<K> key;
+		Info<T> info;
 
-		void set_key(const Key& k) { key=k; free=false; }
-		Key get_key() const { return key; }
+		Case() : free(true) {}
+		Case(const Key<K>& k) : key(k), free(false) {}
 
 		bool isFree() const { return free; }
 };
 
-template<class T>
+template<class K, class T>
 class Table {
 	private:
-		Case<T>* elements;
+		Case<K,T>* elements;
 
 		unsigned int max_elements;
 		unsigned int nb_elements;
 
-		unsigned int (*hash)(const Key&, unsigned int);
-		unsigned int (*rehash)(const Key&, unsigned int);
+		unsigned int (*hash)(const K&, unsigned int);
+		unsigned int (*rehash)(const K&, unsigned int);
 
-		static unsigned int hash_modulo (const Key& k, unsigned int size);
-		static unsigned int rehash_linear (const Key& k, unsigned int try_nb);
+		static unsigned int hash_modulo (const K& k, unsigned int size);
+		static unsigned int rehash_linear (const K& k, unsigned int try_nb);
 
 	public:
-		Table(unsigned int size, unsigned int (*hash)(const Key&, unsigned int)=hash_modulo);
+		Table(unsigned int size, unsigned int (*hash)(const K&, unsigned int)=hash_modulo);
 		~Table();
 
-		void set_hash(unsigned int (*hash)(const Key&, unsigned int));
-		void set_rehash(unsigned int (*rehash)(const Key&, unsigned int));
+		void set_hash(unsigned int (*hash)(const K&, unsigned int));
+		void set_rehash(unsigned int (*rehash)(const K&, unsigned int));
+
+		void add(const K& key, const T& info);
+		void add(const K& key, const Info<T>& info);
+		void add(const Key<K>& key, const Info<T>& info);
+		void add(const Key<K>& key, const T& info);
 
-		void add(const Key& e, const Info<T>& info);
 		void remove(unsigned int hash_code);
 		void show() const;
 
 };
 
-template<class T>
-unsigned int Table<T>::hash_modulo (const Key& k, unsigned int size) { return k % size; }
+template<class K, class T>
+unsigned int Table<K,T>::hash_modulo (const K& k, unsigned int size) { return k % size; }
 
-template<class T>
-unsigned int Table<T>::rehash_linear (const Key& k, unsigned int try_nb) { return 1; }
+template<class K, class T>
+unsigned int Table<K,T>::rehash_linear (const K& k, unsigned int try_nb) { return 1; }
 
-template<class T>
-Table<T>::Table (unsigned int size, unsigned int (*hash)(const Key&, unsigned int))
+template<class K, class T>
+Table<K,T>::Table (unsigned int size, unsigned int (*hash)(const K&, unsigned int))
 	: max_elements(size), nb_elements(0), hash(hash) {
-	elements = new Case<T>[size];
+	elements = new Case<K,T>[size];
 	rehash = rehash_linear;
 }
 
-template<class T>
-Table<T>::~Table () { delete [] elements; }
+template<class K, class T>
+Table<K,T>::~Table () { delete [] elements; }
 
-template<class T>
-void Table<T>::add (const Key& key, const Info<T>& info) {
+template<class K, class T>
+void Table<K,T>::add (const K& key, const T& info) {
 	assert(nb_elements < max_elements);
 
 	unsigned int hash_code = hash(key, max_elements);
@@ -85,15 +87,24 @@ void Table<T>::add (const Key& key, const Info<T>& info) {
 	}
 
 	if (elements[hash_code].free) {
-		elements[hash_code].key = key;
-		elements[hash_code].info.set(info.get());
+		elements[hash_code].key.set(key);
+		elements[hash_code].info.set(info);
 		elements[hash_code].free = false;
 		++nb_elements;
 	}
 }
 
-template<class T>
-void Table<T>::show () const {
+template<class K, class T>
+void Table<K,T>::add (const K& key, const Info<T>& info) { this->add(key,info.get()); }
+
+template<class K, class T>
+void Table<K,T>::add (const Key<K>& key, const Info<T>& info) { this->add(key.get(),info.get()); }
+
+template<class K, class T>
+void Table<K,T>::add (const Key<K>& key, const T& info) { this->add(key.get(),info); }
+
+template<class K, class T>
+void Table<K,T>::show () const {
 	std::cout << "Maximum elements: " << max_elements << std::endl;
 	std::cout << "Elements stored: " << nb_elements << std::endl;
 	for(unsigned int i=0; i<max_elements; ++i) {
@@ -108,10 +119,10 @@ void Table<T>::show () const {
 	}
 }
 
-template<class T>
-void Table<T>::set_hash(unsigned int (*hash)(const Key&, unsigned int)) { this->hash = hash; }
+template<class K, class T>
+void Table<K,T>::set_hash(unsigned int (*hash)(const K&, unsigned int)) { this->hash = hash; }
 
-template<class T>
-void Table<T>::set_rehash(unsigned int (*rehash)(const Key&, unsigned int)) { this->rehash = rehash; }
+template<class K, class T>
+void Table<K,T>::set_rehash(unsigned int (*rehash)(const K&, unsigned int)) { this->rehash = rehash; }
 
 #endif
\ No newline at end of file
-- 
GitLab


From 67089750eae2c7ba277cf36171ae28299508ee4d Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 2 Nov 2020 11:49:29 +0100
Subject: [PATCH 16/23] Moved hash and rehash to Key module

- changed the template parameter T for I (Info) in Table module
---
 tp5/TableDeHachage/src/key.h   |  9 +++++
 tp5/TableDeHachage/src/table.h | 71 +++++++++++++++-------------------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/tp5/TableDeHachage/src/key.h b/tp5/TableDeHachage/src/key.h
index 57accf4..7c2d8d5 100644
--- a/tp5/TableDeHachage/src/key.h
+++ b/tp5/TableDeHachage/src/key.h
@@ -16,6 +16,9 @@ class Key {
 		T get() const;
 		void set(const T& value);
 
+		static unsigned int hash_modulo (const T& k, unsigned int size);
+		static unsigned int rehash_linear (const T& k, unsigned int try_nb);
+
 		friend std::ostream& operator<<(std::ostream& output, const Key<T>& k) { 
 			output << *k.value;
 			return output;
@@ -45,6 +48,12 @@ Key<T>::~Key() {
 	}
 }
 
+template<class T>
+unsigned int Key<T>::hash_modulo (const T& k, unsigned int size) { return k % size; }
+
+template<class T>
+unsigned int Key<T>::rehash_linear (const T& k, unsigned int try_nb) { return 1; }
+
 template<class T>
 T Key<T>::get() const { return *value; }
 
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index 807861b..e9556f6 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -5,19 +5,19 @@
 #include "key.h"
 #include "info.h"
 
-template<class K, class T>
+template<class K, class I>
 class Table;
 
-template<class K, class T>
+template<class K, class I>
 class Case {
-	friend class Table<K,T>;
+	friend class Table<K,I>;
 
 	private:
 		bool free;
 
 	public:
 		Key<K> key;
-		Info<T> info;
+		Info<I> info;
 
 		Case() : free(true) {}
 		Case(const Key<K>& k) : key(k), free(false) {}
@@ -25,10 +25,10 @@ class Case {
 		bool isFree() const { return free; }
 };
 
-template<class K, class T>
+template<class K, class I>
 class Table {
 	private:
-		Case<K,T>* elements;
+		Case<K,I>* elements;
 
 		unsigned int max_elements;
 		unsigned int nb_elements;
@@ -36,44 +36,35 @@ class Table {
 		unsigned int (*hash)(const K&, unsigned int);
 		unsigned int (*rehash)(const K&, unsigned int);
 
-		static unsigned int hash_modulo (const K& k, unsigned int size);
-		static unsigned int rehash_linear (const K& k, unsigned int try_nb);
-
 	public:
-		Table(unsigned int size, unsigned int (*hash)(const K&, unsigned int)=hash_modulo);
+		Table(unsigned int size, unsigned int (*hash)(const K&, unsigned int)=Key<K>::hash_modulo);
 		~Table();
 
 		void set_hash(unsigned int (*hash)(const K&, unsigned int));
 		void set_rehash(unsigned int (*rehash)(const K&, unsigned int));
 
-		void add(const K& key, const T& info);
-		void add(const K& key, const Info<T>& info);
-		void add(const Key<K>& key, const Info<T>& info);
-		void add(const Key<K>& key, const T& info);
+		void add(const K& key, const I& info);
+		void add(const K& key, const Info<I>& info);
+		void add(const Key<K>& key, const Info<I>& info);
+		void add(const Key<K>& key, const I& info);
 
 		void remove(unsigned int hash_code);
 		void show() const;
 
 };
 
-template<class K, class T>
-unsigned int Table<K,T>::hash_modulo (const K& k, unsigned int size) { return k % size; }
-
-template<class K, class T>
-unsigned int Table<K,T>::rehash_linear (const K& k, unsigned int try_nb) { return 1; }
-
-template<class K, class T>
-Table<K,T>::Table (unsigned int size, unsigned int (*hash)(const K&, unsigned int))
+template<class K, class I>
+Table<K,I>::Table (unsigned int size, unsigned int (*hash)(const K&, unsigned int))
 	: max_elements(size), nb_elements(0), hash(hash) {
-	elements = new Case<K,T>[size];
-	rehash = rehash_linear;
+	elements = new Case<K,I>[size];
+	rehash = Key<K>::rehash_linear;
 }
 
-template<class K, class T>
-Table<K,T>::~Table () { delete [] elements; }
+template<class K, class I>
+Table<K,I>::~Table () { delete [] elements; }
 
-template<class K, class T>
-void Table<K,T>::add (const K& key, const T& info) {
+template<class K, class I>
+void Table<K,I>::add (const K& key, const I& info) {
 	assert(nb_elements < max_elements);
 
 	unsigned int hash_code = hash(key, max_elements);
@@ -94,17 +85,17 @@ void Table<K,T>::add (const K& key, const T& info) {
 	}
 }
 
-template<class K, class T>
-void Table<K,T>::add (const K& key, const Info<T>& info) { this->add(key,info.get()); }
+template<class K, class I>
+void Table<K,I>::add (const K& key, const Info<I>& info) { this->add(key,info.get()); }
 
-template<class K, class T>
-void Table<K,T>::add (const Key<K>& key, const Info<T>& info) { this->add(key.get(),info.get()); }
+template<class K, class I>
+void Table<K,I>::add (const Key<K>& key, const Info<I>& info) { this->add(key.get(),info.get()); }
 
-template<class K, class T>
-void Table<K,T>::add (const Key<K>& key, const T& info) { this->add(key.get(),info); }
+template<class K, class I>
+void Table<K,I>::add (const Key<K>& key, const I& info) { this->add(key.get(),info); }
 
-template<class K, class T>
-void Table<K,T>::show () const {
+template<class K, class I>
+void Table<K,I>::show () const {
 	std::cout << "Maximum elements: " << max_elements << std::endl;
 	std::cout << "Elements stored: " << nb_elements << std::endl;
 	for(unsigned int i=0; i<max_elements; ++i) {
@@ -119,10 +110,10 @@ void Table<K,T>::show () const {
 	}
 }
 
-template<class K, class T>
-void Table<K,T>::set_hash(unsigned int (*hash)(const K&, unsigned int)) { this->hash = hash; }
+template<class K, class I>
+void Table<K,I>::set_hash(unsigned int (*hash)(const K&, unsigned int)) { this->hash = hash; }
 
-template<class K, class T>
-void Table<K,T>::set_rehash(unsigned int (*rehash)(const K&, unsigned int)) { this->rehash = rehash; }
+template<class K, class I>
+void Table<K,I>::set_rehash(unsigned int (*rehash)(const K&, unsigned int)) { this->rehash = rehash; }
 
 #endif
\ No newline at end of file
-- 
GitLab


From b3afdaabc8e9d5c948e9821923404fd3692c622d Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Mon, 2 Nov 2020 12:00:06 +0100
Subject: [PATCH 17/23] Changed Table Constructor

- added rehash parameter with a default argument 'rehash_linear'
---
 tp5/TableDeHachage/src/table.h | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index e9556f6..d5279fe 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -37,7 +37,9 @@ class Table {
 		unsigned int (*rehash)(const K&, unsigned int);
 
 	public:
-		Table(unsigned int size, unsigned int (*hash)(const K&, unsigned int)=Key<K>::hash_modulo);
+		Table(unsigned int size,
+		      unsigned int (*hash)(const K&, unsigned int)=Key<K>::hash_modulo,
+		      unsigned int (*rehash)(const K&, unsigned int)=Key<K>::rehash_linear);
 		~Table();
 
 		void set_hash(unsigned int (*hash)(const K&, unsigned int));
@@ -54,10 +56,11 @@ class Table {
 };
 
 template<class K, class I>
-Table<K,I>::Table (unsigned int size, unsigned int (*hash)(const K&, unsigned int))
-	: max_elements(size), nb_elements(0), hash(hash) {
+Table<K,I>::Table (unsigned int size,
+				   unsigned int (*hash)(const K&, unsigned int),
+				   unsigned int (*rehash)(const K&, unsigned int))
+				   : max_elements(size), nb_elements(0), hash(hash), rehash(rehash) {
 	elements = new Case<K,I>[size];
-	rehash = Key<K>::rehash_linear;
 }
 
 template<class K, class I>
-- 
GitLab


From 2d6f0a237a9057bd954ee4597436dcb1766b0aa2 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 3 Nov 2020 13:43:34 +0100
Subject: [PATCH 18/23] Info and Key are no longer pointers, + 'find' function

- Info and Key contain elements and not pointers
- Only unique key can be inserted (assert used)
- 'find' function takes KEY and returns INFO
---
 tp5/TableDeHachage/src/info.h   | 38 +++++++++++++---------------
 tp5/TableDeHachage/src/key.h    | 45 ++++++++++++++++++---------------
 tp5/TableDeHachage/src/main.cpp |  5 ++--
 tp5/TableDeHachage/src/table.h  | 36 ++++++++++++++++++++++----
 4 files changed, 75 insertions(+), 49 deletions(-)

diff --git a/tp5/TableDeHachage/src/info.h b/tp5/TableDeHachage/src/info.h
index 2795922..d5440b6 100644
--- a/tp5/TableDeHachage/src/info.h
+++ b/tp5/TableDeHachage/src/info.h
@@ -6,58 +6,54 @@
 template<class T>
 class Info {
 	private:
-		T* value;
+		T value;
+		bool empty;
 
 	public:
 		Info();
 		Info(const T& value);
-		~Info();
 
 		T get() const;
 		void set(const T& value);
 
+		bool isEmpty() const;
+
+		Info<T>& operator=(const Info<T>& info);
+
 		friend std::ostream& operator<<(std::ostream& output, const Info<T>& i) { 
-			output << *i.value;
+			output << i.value;
 			return output;
 		}
 
 		friend std::istream& operator>>(std::istream& input, Info<T>& i) {
 			T temp;
 			input >> temp;
-			i.value = new T(temp);
+			i.value = temp;
 			return input;
 		}
-
-		Info<T>& operator=(const Info<T>& info);
 };
 
 template<class T>
-Info<T>::Info() { value = nullptr; }
+Info<T>::Info() : empty(true) {}
 
 template<class T>
-Info<T>::Info(const T& value) { this->value = new T(value); }
+Info<T>::Info(const T& val) : value(val), empty(false) {}
 
 template<class T>
-Info<T>::~Info() {
-	if(value) {
-		delete value;
-		value = nullptr;
-	}
-}
-
-template<class T>
-T Info<T>::get() const { return *value; }
+T Info<T>::get() const { return value; }
 
 template<class T>
 void Info<T>::set(const T& val) {
-	if (!this->value) this->value = new T(val);
-	else *this->value = val;
+	this->value = val;
+	empty = false;
 }
 
+template<class T>
+bool Info<T>::isEmpty() const { return empty; }
+
 template<class T>
 Info<T>& Info<T>::operator=(const Info<T>& info) {
-	if (!this->value) this->value = new T(*info.value);
-	else *this->value = *info.value;
+	this->value = info.value;
 	return *this;
 }
 
diff --git a/tp5/TableDeHachage/src/key.h b/tp5/TableDeHachage/src/key.h
index 7c2d8d5..9538b6b 100644
--- a/tp5/TableDeHachage/src/key.h
+++ b/tp5/TableDeHachage/src/key.h
@@ -6,47 +6,48 @@
 template<class T>
 class Key {
 	private:
-		T* value;
+		T value;
+		bool empty;
+		unsigned int try_count;
 
 	public:
 		Key();
 		Key(const T& value);
-		~Key();
 
 		T get() const;
 		void set(const T& value);
 
+		bool isEmpty() const;
+
+		Key<T>& operator=(const Key<T>& key);
+
+		unsigned int get_try_count() const;
+		void set_try_count(unsigned int nb);
+
 		static unsigned int hash_modulo (const T& k, unsigned int size);
 		static unsigned int rehash_linear (const T& k, unsigned int try_nb);
 
 		friend std::ostream& operator<<(std::ostream& output, const Key<T>& k) { 
-			output << *k.value;
+			output << k.value;
 			return output;
 		}
 
 		friend std::istream& operator>>(std::istream& input, Key<T>& k) {
 			T temp;
 			input >> temp;
-			k.value = new T(temp);
+			k.value = temp;
 			return input;
 		}
-
-		Key<T>& operator=(const Key<T>& key);
 };
 
 template<class T>
-Key<T>::Key() { value = nullptr; }
+Key<T>::Key() : empty(true), try_count(0) {}
 
 template<class T>
-Key<T>::Key(const T& value) { this->value = new T(value); }
+Key<T>::Key(const T& val) : value(val), empty(false), try_count(0) {}
 
 template<class T>
-Key<T>::~Key() {
-	if(value) {
-		delete value;
-		value = nullptr;
-	}
-}
+bool Key<T>::isEmpty() const { return empty; }
 
 template<class T>
 unsigned int Key<T>::hash_modulo (const T& k, unsigned int size) { return k % size; }
@@ -55,18 +56,20 @@ template<class T>
 unsigned int Key<T>::rehash_linear (const T& k, unsigned int try_nb) { return 1; }
 
 template<class T>
-T Key<T>::get() const { return *value; }
+T Key<T>::get() const { return value; }
 
 template<class T>
-void Key<T>::set(const T& val) {
-	if (!this->value) this->value = new T(val);
-	else *this->value = val;
-}
+void Key<T>::set(const T& val) { this->value = val; }
+
+template<class T>
+unsigned int Key<T>::get_try_count() const { return try_count; }
+
+template<class T>
+void Key<T>::set_try_count(unsigned int nb) { try_count = nb; }
 
 template<class T>
 Key<T>& Key<T>::operator=(const Key<T>& key) {
-	if (!this->value) this->value = new T(*key.value);
-	else *this->value = *key.value;
+	this->value = key.value;
 	return *this;
 }
 
diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
index 8dd1548..281b0db 100644
--- a/tp5/TableDeHachage/src/main.cpp
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -23,12 +23,13 @@ int main() {
     // i3 = std::string("nine");
 
     t.add(8, std::string("toto"));
-    t.add(8, std::string("toto"));
-    t.add(2, std::string("toto"));
     t.add(2, std::string("mew"));
     t.add(9, std::string("nine"));
 
     t.show();
 
+    InfoString s = t.find(9);
+    std::cout << "Info of 9: " << s << std::endl;
+
     return 0;
 }
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index d5279fe..97035dd 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -13,15 +13,17 @@ class Case {
 	friend class Table<K,I>;
 
 	private:
-		bool free;
-
-	public:
 		Key<K> key;
 		Info<I> info;
+		bool free;
 
+	public:
 		Case() : free(true) {}
 		Case(const Key<K>& k) : key(k), free(false) {}
 
+		Key<K> get_key() const { return key; }
+		Info<I> get_info() const { return info; }
+
 		bool isFree() const { return free; }
 };
 
@@ -50,7 +52,9 @@ class Table {
 		void add(const Key<K>& key, const Info<I>& info);
 		void add(const Key<K>& key, const I& info);
 
-		void remove(unsigned int hash_code);
+		Info<I> find(const K& key) const;
+		Info<I> find(const Key<K>& key) const;
+
 		void show() const;
 
 };
@@ -64,13 +68,17 @@ Table<K,I>::Table (unsigned int size,
 }
 
 template<class K, class I>
-Table<K,I>::~Table () { delete [] elements; }
+Table<K,I>::~Table () { delete [] elements; elements = nullptr; }
 
 template<class K, class I>
 void Table<K,I>::add (const K& key, const I& info) {
 	assert(nb_elements < max_elements);
 
 	unsigned int hash_code = hash(key, max_elements);
+
+	if(!elements[hash_code].free)
+		assert(elements[hash_code].key.get() != key);
+
 	unsigned int try_nb = 1;
 
 	while(!elements[hash_code].free) {
@@ -82,6 +90,7 @@ void Table<K,I>::add (const K& key, const I& info) {
 
 	if (elements[hash_code].free) {
 		elements[hash_code].key.set(key);
+		elements[hash_code].key.set_try_count(try_nb);
 		elements[hash_code].info.set(info);
 		elements[hash_code].free = false;
 		++nb_elements;
@@ -105,6 +114,8 @@ void Table<K,I>::show () const {
 		if(!elements[i].free) {
 			std::cout << "[" << elements[i].key << "->";
 			std::cout << elements[i].info << "]";
+			// std::cout << elements[i].info << "->";
+			// std::cout << elements[i].key.get_try_count() << "]";
 		}
 		else std::cout << "[ ]";
 
@@ -119,4 +130,19 @@ void Table<K,I>::set_hash(unsigned int (*hash)(const K&, unsigned int)) { this->
 template<class K, class I>
 void Table<K,I>::set_rehash(unsigned int (*rehash)(const K&, unsigned int)) { this->rehash = rehash; }
 
+template<class K, class I>
+Info<I> Table<K,I>::find(const K& key) const {
+	unsigned int index = hash(key, max_elements);
+
+	assert(!elements[index].free);
+	
+	while (elements[index].key.get() != key)
+		index += rehash(key, max_elements);
+	
+	return elements[index].info;
+}
+
+template<class K, class I>
+Info<I> Table<K,I>::find(const Key<K>& key) const { return find(key.get()); }
+
 #endif
\ No newline at end of file
-- 
GitLab


From f3f1e8ac47c1709b8fba98e6b40eb9f0e1959815 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 3 Nov 2020 16:11:54 +0100
Subject: [PATCH 19/23] Improved Draw Function

---
 tp5/TableDeHachage/src/info.h   | 44 +++++++++++++++++--
 tp5/TableDeHachage/src/key.h    | 48 ++++++++++++++++++---
 tp5/TableDeHachage/src/main.cpp |  9 +++-
 tp5/TableDeHachage/src/table.h  | 76 ++++++++++++++++++++++++---------
 4 files changed, 145 insertions(+), 32 deletions(-)

diff --git a/tp5/TableDeHachage/src/info.h b/tp5/TableDeHachage/src/info.h
index d5440b6..cbe92f9 100644
--- a/tp5/TableDeHachage/src/info.h
+++ b/tp5/TableDeHachage/src/info.h
@@ -2,6 +2,7 @@
 #define _INFO
 
 #include <iostream>
+#include <assert.h>
 
 template<class T>
 class Info {
@@ -19,6 +20,13 @@ class Info {
 		bool isEmpty() const;
 
 		Info<T>& operator=(const Info<T>& info);
+		Info<T>& operator=(const T& info);
+
+		bool operator==(const Info<T>& info) const;
+		bool operator==(const T& info) const;
+
+		bool operator!=(const Info<T>& info) const;
+		bool operator!=(const T& info) const;
 
 		friend std::ostream& operator<<(std::ostream& output, const Info<T>& i) { 
 			output << i.value;
@@ -26,9 +34,7 @@ class Info {
 		}
 
 		friend std::istream& operator>>(std::istream& input, Info<T>& i) {
-			T temp;
-			input >> temp;
-			i.value = temp;
+			input >> i.value;
 			return input;
 		}
 };
@@ -53,8 +59,38 @@ bool Info<T>::isEmpty() const { return empty; }
 
 template<class T>
 Info<T>& Info<T>::operator=(const Info<T>& info) {
-	this->value = info.value;
+	set(info.value);
 	return *this;
 }
 
+template<class T>
+Info<T>& Info<T>::operator=(const T& info) {
+	set(info);
+	return *this;
+}
+
+template<class T>
+bool Info<T>::operator==(const Info<T>& info) const {
+	assert(!empty && !info.empty);
+	return this->value == info.value;
+}
+
+template<class T>
+bool Info<T>::operator==(const T& info) const {
+	assert(!empty);
+	return this->value == info;
+}
+
+template<class T>
+bool Info<T>::operator!=(const Info<T>& info) const {
+	assert(!empty && !info.empty);
+	return this->value != info.value;
+}
+
+template<class T>
+bool Info<T>::operator!=(const T& info) const {
+	assert(!empty);
+	return this->value != info;
+}
+
 #endif
diff --git a/tp5/TableDeHachage/src/key.h b/tp5/TableDeHachage/src/key.h
index 9538b6b..f4464a0 100644
--- a/tp5/TableDeHachage/src/key.h
+++ b/tp5/TableDeHachage/src/key.h
@@ -20,6 +20,13 @@ class Key {
 		bool isEmpty() const;
 
 		Key<T>& operator=(const Key<T>& key);
+		Key<T>& operator=(const T& key);
+
+		bool operator==(const Key<T>& key) const;
+		bool operator==(const T& key) const;
+
+		bool operator!=(const Key<T>& key) const;
+		bool operator!=(const T& key) const;
 
 		unsigned int get_try_count() const;
 		void set_try_count(unsigned int nb);
@@ -33,9 +40,7 @@ class Key {
 		}
 
 		friend std::istream& operator>>(std::istream& input, Key<T>& k) {
-			T temp;
-			input >> temp;
-			k.value = temp;
+			input >> k.value;
 			return input;
 		}
 };
@@ -59,7 +64,10 @@ template<class T>
 T Key<T>::get() const { return value; }
 
 template<class T>
-void Key<T>::set(const T& val) { this->value = val; }
+void Key<T>::set(const T& val) {
+	this->value = val;
+	empty = false;
+}
 
 template<class T>
 unsigned int Key<T>::get_try_count() const { return try_count; }
@@ -69,8 +77,38 @@ void Key<T>::set_try_count(unsigned int nb) { try_count = nb; }
 
 template<class T>
 Key<T>& Key<T>::operator=(const Key<T>& key) {
-	this->value = key.value;
+	set(key.value);
+	return *this;
+}
+
+template<class T>
+Key<T>& Key<T>::operator=(const T& key) {
+	set(key);
 	return *this;
 }
 
+template<class T>
+bool Key<T>::operator==(const Key<T>& key) const {
+	assert(!empty && !key.empty);
+	return this->value == key.value;
+}
+
+template<class T>
+bool Key<T>::operator==(const T& key) const {
+	assert(!empty);
+	return this->value == key;
+}
+
+template<class T>
+bool Key<T>::operator!=(const Key<T>& key) const {
+	assert(!empty && !key.empty);
+	return this->value != key.value;
+}
+
+template<class T>
+bool Key<T>::operator!=(const T& key) const {
+	assert(!empty);
+	return this->value != key;
+}
+
 #endif
diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
index 281b0db..012ff90 100644
--- a/tp5/TableDeHachage/src/main.cpp
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -26,10 +26,15 @@ int main() {
     t.add(2, std::string("mew"));
     t.add(9, std::string("nine"));
 
+    t.show(true);
+
+    std::cout << "Info of 9: " << t[9] << std::endl;
+
+    t.remove(2);
     t.show();
 
-    InfoString s = t.find(9);
-    std::cout << "Info of 9: " << s << std::endl;
+    t.add(2, std::string("tata"));
+    t.show();
 
     return 0;
 }
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index 97035dd..d381173 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -8,6 +8,7 @@
 template<class K, class I>
 class Table;
 
+//====================== Case ===========================
 template<class K, class I>
 class Case {
 	friend class Table<K,I>;
@@ -25,8 +26,17 @@ class Case {
 		Info<I> get_info() const { return info; }
 
 		bool isFree() const { return free; }
+
+		void draw() const {
+			if(!free) {
+				unsigned int try_count = key.get_try_count();
+				std::cout << key << "	⏵ " << info;
+				std::cout << " (" << try_count << (try_count==1 ? " try" : " tries") << ")" << std::endl;
+			}
+		}
 };
 
+// ======================== Table ==========================
 template<class K, class I>
 class Table {
 	private:
@@ -52,10 +62,17 @@ class Table {
 		void add(const Key<K>& key, const Info<I>& info);
 		void add(const Key<K>& key, const I& info);
 
-		Info<I> find(const K& key) const;
-		Info<I> find(const Key<K>& key) const;
+		Info<I> get_info(const K& key) const;
+		Info<I> get_info(const Key<K>& key) const;
+
+		unsigned int find(const K& key) const;
+		unsigned int find(const Key<K>& key) const;
 
-		void show() const;
+		void remove(const K& key);
+
+		Info<I> operator[](const K& key) const;
+
+		void show(bool extra=false) const;
 
 };
 
@@ -77,7 +94,7 @@ void Table<K,I>::add (const K& key, const I& info) {
 	unsigned int hash_code = hash(key, max_elements);
 
 	if(!elements[hash_code].free)
-		assert(elements[hash_code].key.get() != key);
+		assert(elements[hash_code].key != key);
 
 	unsigned int try_nb = 1;
 
@@ -107,21 +124,18 @@ template<class K, class I>
 void Table<K,I>::add (const Key<K>& key, const I& info) { this->add(key.get(),info); }
 
 template<class K, class I>
-void Table<K,I>::show () const {
-	std::cout << "Maximum elements: " << max_elements << std::endl;
-	std::cout << "Elements stored: " << nb_elements << std::endl;
+void Table<K,I>::show (bool extra) const {
+	if (extra) {
+		std::cout << "Maximum elements: " << max_elements << std::endl;
+		std::cout << "Elements stored: " << nb_elements << std::endl;
+	}
+	std::cout << "========== Table State ========== \n";
+	std::cout << "#INDEX	KEY	⏵ INFO\n";
 	for(unsigned int i=0; i<max_elements; ++i) {
-		if(!elements[i].free) {
-			std::cout << "[" << elements[i].key << "->";
-			std::cout << elements[i].info << "]";
-			// std::cout << elements[i].info << "->";
-			// std::cout << elements[i].key.get_try_count() << "]";
-		}
-		else std::cout << "[ ]";
-
-		if (i==max_elements-1) std::cout << std::endl;
-		else std::cout << "  ";
+		if(!elements[i].free) std::cout << "#" << i << "	";
+		elements[i].draw();
 	}
+	std::cout << "================================= \n";
 }
 
 template<class K, class I>
@@ -131,18 +145,38 @@ template<class K, class I>
 void Table<K,I>::set_rehash(unsigned int (*rehash)(const K&, unsigned int)) { this->rehash = rehash; }
 
 template<class K, class I>
-Info<I> Table<K,I>::find(const K& key) const {
+Info<I> Table<K,I>::get_info(const K& key) const {
+	unsigned int index = find(key);
+	return elements[index].info;
+}
+
+template<class K, class I>
+Info<I> Table<K,I>::get_info(const Key<K>& key) const { return get_info(key.get()); }
+
+template<class K, class I>
+unsigned int Table<K,I>::find(const K& key) const {
 	unsigned int index = hash(key, max_elements);
 
 	assert(!elements[index].free);
 	
-	while (elements[index].key.get() != key)
+	while (elements[index].key != key)
 		index += rehash(key, max_elements);
 	
-	return elements[index].info;
+	return index;
+}
+
+template<class K, class I>
+unsigned int Table<K,I>::find(const Key<K>& key) const { return find(key.get()); }
+
+template<class K, class I>
+void Table<K,I>::remove(const K& key) {
+	unsigned int index = find(key);
+
+	elements[index].free = true;
+	--nb_elements;
 }
 
 template<class K, class I>
-Info<I> Table<K,I>::find(const Key<K>& key) const { return find(key.get()); }
+Info<I> Table<K,I>::operator[](const K& key) const { return get_info(key); }
 
 #endif
\ No newline at end of file
-- 
GitLab


From b753201d34e0442ad0655200c91f08afb3dc31b9 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 3 Nov 2020 16:27:17 +0100
Subject: [PATCH 20/23] Improved Draw Function

---
 tp5/TableDeHachage/src/main.cpp |  3 +++
 tp5/TableDeHachage/src/table.h  | 15 +++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
index 012ff90..099721b 100644
--- a/tp5/TableDeHachage/src/main.cpp
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -36,5 +36,8 @@ int main() {
     t.add(2, std::string("tata"));
     t.show();
 
+    t.set_info(9, "domik");
+    t.show();
+
     return 0;
 }
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index d381173..5e73ab9 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -65,6 +65,9 @@ class Table {
 		Info<I> get_info(const K& key) const;
 		Info<I> get_info(const Key<K>& key) const;
 
+		void set_info(const K& key, const I& info);
+		void set_info(const Key<K>& key, const Info<I>& info);
+
 		unsigned int find(const K& key) const;
 		unsigned int find(const Key<K>& key) const;
 
@@ -179,4 +182,16 @@ void Table<K,I>::remove(const K& key) {
 template<class K, class I>
 Info<I> Table<K,I>::operator[](const K& key) const { return get_info(key); }
 
+template<class K, class I>
+void Table<K,I>::set_info(const K& key, const I& info) {
+	unsigned int index = find(key);
+	elements[index].info = info;
+}
+
+template<class K, class I>
+void Table<K,I>::set_info(const Key<K>& key, const Info<I>& info) {
+	unsigned int index = find(key);
+	elements[index].info = info;
+}
+
 #endif
\ No newline at end of file
-- 
GitLab


From 3088f6e20f1d811f2cde59efa2b313b414c014db Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 3 Nov 2020 16:37:34 +0100
Subject: [PATCH 21/23] Devided Case into definition and implementation

- removed useless .cpp files
---
 tp5/TableDeHachage/makefile      |  8 +----
 tp5/TableDeHachage/src/info.cpp  |  1 -
 tp5/TableDeHachage/src/main.cpp  |  2 +-
 tp5/TableDeHachage/src/table.cpp | 50 --------------------------------
 tp5/TableDeHachage/src/table.h   | 50 +++++++++++++++++++++++---------
 5 files changed, 38 insertions(+), 73 deletions(-)
 delete mode 100644 tp5/TableDeHachage/src/info.cpp
 delete mode 100644 tp5/TableDeHachage/src/table.cpp

diff --git a/tp5/TableDeHachage/makefile b/tp5/TableDeHachage/makefile
index edb678d..e751cf3 100644
--- a/tp5/TableDeHachage/makefile
+++ b/tp5/TableDeHachage/makefile
@@ -1,17 +1,11 @@
 all: bin/executable.out
 
-bin/executable.out: obj/main.o obj/table.o obj/info.o
+bin/executable.out: obj/main.o
 	g++ -Wall -g obj/main.o obj/table.o obj/info.o -o bin/executable.out
 
 obj/main.o: src/main.cpp src/table.h src/key.h src/info.h
 	g++ -Wall -g -c src/main.cpp -o obj/main.o
 
-obj/table.o: src/table.h src/table.cpp src/key.h src/info.h
-	g++ -Wall -g -c src/table.cpp -o obj/table.o
-
-obj/info.o: src/info.h src/info.cpp
-	g++ -Wall -g -c src/info.cpp -o obj/info.o
-
 clean:
 	rm obj/*
 
diff --git a/tp5/TableDeHachage/src/info.cpp b/tp5/TableDeHachage/src/info.cpp
deleted file mode 100644
index 4132463..0000000
--- a/tp5/TableDeHachage/src/info.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "info.h"
\ No newline at end of file
diff --git a/tp5/TableDeHachage/src/main.cpp b/tp5/TableDeHachage/src/main.cpp
index 099721b..d940f23 100644
--- a/tp5/TableDeHachage/src/main.cpp
+++ b/tp5/TableDeHachage/src/main.cpp
@@ -36,7 +36,7 @@ int main() {
     t.add(2, std::string("tata"));
     t.show();
 
-    t.set_info(9, "domik");
+    t.set_info(9, "dom");
     t.show();
 
     return 0;
diff --git a/tp5/TableDeHachage/src/table.cpp b/tp5/TableDeHachage/src/table.cpp
deleted file mode 100644
index e042f47..0000000
--- a/tp5/TableDeHachage/src/table.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// #include "table.h"
-// #include <iostream>
-
-// unsigned int Table::hash_modulo (const Key& k, unsigned int size) { return k % size; }
-
-// unsigned int Table::rehash_linear (const Key& k, unsigned int try_nb) { return 1; }
-
-// Table::Table (unsigned int size, unsigned int (*hash)(const Key&, unsigned int))
-// 	: max_elements(size), nb_elements(0), hash(hash) {
-// 	elements = new Case[size];
-// 	rehash = rehash_linear;
-// }
-
-// Table::~Table () { delete [] elements; }
-
-// void Table::add (const Key& key) {
-// 	assert(nb_elements < max_elements);
-
-// 	unsigned int hash_code = hash(key, max_elements);
-// 	unsigned int try_nb = 1;
-
-// 	while(!elements[hash_code].free) {
-// 		hash_code += rehash(key, try_nb++);
-// 		if(hash_code >= max_elements) {
-// 			hash_code = hash_code % max_elements;
-// 		}
-// 	}
-
-// 	if (elements[hash_code].free) {
-// 		elements[hash_code].key = key;
-// 		elements[hash_code].free = false;
-// 		++nb_elements;
-// 	}
-// }
-
-// void Table::show () const {
-// 	std::cout << "Maximum elements: " << max_elements << std::endl;
-// 	std::cout << "Elements stored: " << nb_elements << std::endl;
-// 	for(unsigned int i=0; i<max_elements; ++i) {
-// 		if(!elements[i].free) std::cout << "[" << elements[i].key << "]";
-// 		else std::cout << "[ ]";
-
-// 		if (i==max_elements-1) std::cout << std::endl;
-// 		else std::cout << "  ";
-// 	}
-// }
-
-// void Table::set_hash(unsigned int (*hash)(const Key&, unsigned int)) { this->hash = hash; }
-
-// void Table::set_rehash(unsigned int (*rehash)(const Key&, unsigned int)) { this->rehash = rehash; }
\ No newline at end of file
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index 5e73ab9..64091e9 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -8,7 +8,7 @@
 template<class K, class I>
 class Table;
 
-//====================== Case ===========================
+//====================== Case Definition ===========================
 template<class K, class I>
 class Case {
 	friend class Table<K,I>;
@@ -19,24 +19,45 @@ class Case {
 		bool free;
 
 	public:
-		Case() : free(true) {}
-		Case(const Key<K>& k) : key(k), free(false) {}
+		Case();
+		Case(const Key<K>& k);
 
-		Key<K> get_key() const { return key; }
-		Info<I> get_info() const { return info; }
+		Key<K> get_key() const;
+		Info<I> get_info() const;
 
-		bool isFree() const { return free; }
+		bool isFree() const;
 
-		void draw() const {
-			if(!free) {
-				unsigned int try_count = key.get_try_count();
-				std::cout << key << "	⏵ " << info;
-				std::cout << " (" << try_count << (try_count==1 ? " try" : " tries") << ")" << std::endl;
-			}
-		}
+		void draw() const;
 };
 
-// ======================== Table ==========================
+//====================== Case Implementation ===========================
+template<class K, class I>
+Case<K,I>::Case() : free(true) {}
+
+template<class K, class I>
+Case<K,I>::Case(const Key<K>& k) : key(k), free(false) {}
+
+template<class K, class I>
+Key<K> Case<K,I>::get_key() const { return key; }
+
+template<class K, class I>
+Info<I> Case<K,I>::get_info() const { return info; }
+
+template<class K, class I>
+bool Case<K,I>::isFree() const { return free; }
+
+template<class K, class I>
+void Case<K,I>::draw() const {
+	if(!free) {
+		unsigned int try_count = key.get_try_count();
+		std::cout << key << "	⏵ " << info;
+		std::cout << " (" << try_count << (try_count==1 ? " try" : " tries") << ")" << std::endl;
+	}
+}
+
+
+
+// ======================== Table Definition ==========================
 template<class K, class I>
 class Table {
 	private:
@@ -79,6 +100,7 @@ class Table {
 
 };
 
+// ======================== Table Implementation ==========================
 template<class K, class I>
 Table<K,I>::Table (unsigned int size,
 				   unsigned int (*hash)(const K&, unsigned int),
-- 
GitLab


From 70aea25892504ecaa81a07490b9404763ee57775 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 3 Nov 2020 16:40:27 +0100
Subject: [PATCH 22/23] Fixed Makefile

- compilation wasn't working because deleted info.o table.o files
---
 tp5/TableDeHachage/makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tp5/TableDeHachage/makefile b/tp5/TableDeHachage/makefile
index e751cf3..0c520f8 100644
--- a/tp5/TableDeHachage/makefile
+++ b/tp5/TableDeHachage/makefile
@@ -1,7 +1,7 @@
 all: bin/executable.out
 
 bin/executable.out: obj/main.o
-	g++ -Wall -g obj/main.o obj/table.o obj/info.o -o bin/executable.out
+	g++ -Wall -g obj/main.o -o bin/executable.out
 
 obj/main.o: src/main.cpp src/table.h src/key.h src/info.h
 	g++ -Wall -g -c src/main.cpp -o obj/main.o
-- 
GitLab


From a16308f2cced3c2cc6b97b18624ef8533f612873 Mon Sep 17 00:00:00 2001
From: Eldar <eldar.kasmamytov@gmail.com>
Date: Tue, 3 Nov 2020 17:36:19 +0100
Subject: [PATCH 23/23] Added Documentation

- Comments in header files
---
 tp5/TableDeHachage/src/info.h  | 27 ++++++++++++++++++--
 tp5/TableDeHachage/src/key.h   | 35 ++++++++++++++++++++++++--
 tp5/TableDeHachage/src/table.h | 45 +++++++++++++++++++++++++++++++---
 3 files changed, 100 insertions(+), 7 deletions(-)

diff --git a/tp5/TableDeHachage/src/info.h b/tp5/TableDeHachage/src/info.h
index cbe92f9..a759ec0 100644
--- a/tp5/TableDeHachage/src/info.h
+++ b/tp5/TableDeHachage/src/info.h
@@ -1,44 +1,67 @@
+// Eldar Kasmamytov
+
 #ifndef _INFO
 #define _INFO
 
 #include <iostream>
 #include <assert.h>
 
+// Attention!
+// La definition et l'implementation des classes sont dans le meme fichier,
+// car ce sont des classes TEMPLATE, en consequence on peut pas diviser
+// le definition et l'implementation en deux fichiers.
+
+//====================== Info Definition ===========================
 template<class T>
 class Info {
 	private:
 		T value;
-		bool empty;
+		bool empty; // Indique si 'value' est vide ou pas
 
 	public:
+		// Constructeurs
 		Info();
 		Info(const T& value);
 
+		// Resultat: L'information stockee dans la variable 'value' de la classe.
 		T get() const;
+
+		// Postcondition: L'information est initialisee ou mise a jour par la valeur 'value'.
 		void set(const T& value);
 
+		// Resultat: True si l'Info ne contient pas de valeur,
+		//			 False sinon.
 		bool isEmpty() const;
 
-		Info<T>& operator=(const Info<T>& info);
+		// Resultat: Retourne l'Info affectee.
+		// Postcondition: L'information est initialisee ou mise a jour par la valeur 'info'.
 		Info<T>& operator=(const T& info);
+		Info<T>& operator=(const Info<T>& info);
 
+		// Resultat: True si l'information des deux Infos est identique,
+		//			 False sinon.
 		bool operator==(const Info<T>& info) const;
 		bool operator==(const T& info) const;
 
+		// Resultat: True si les informations des deux Infos ne sont pas identiques,
+		//			 False sinon.
 		bool operator!=(const Info<T>& info) const;
 		bool operator!=(const T& info) const;
 
+		// Surcharhe de l'operateur '<<'
 		friend std::ostream& operator<<(std::ostream& output, const Info<T>& i) { 
 			output << i.value;
 			return output;
 		}
 
+		// Surcharhe de l'operateur '>>'
 		friend std::istream& operator>>(std::istream& input, Info<T>& i) {
 			input >> i.value;
 			return input;
 		}
 };
 
+//====================== Info Implementation ===========================
 template<class T>
 Info<T>::Info() : empty(true) {}
 
diff --git a/tp5/TableDeHachage/src/key.h b/tp5/TableDeHachage/src/key.h
index f4464a0..f878ea4 100644
--- a/tp5/TableDeHachage/src/key.h
+++ b/tp5/TableDeHachage/src/key.h
@@ -1,50 +1,81 @@
+// Eldar Kasmamytov
+
 #ifndef _KEY
 #define _KEY
 
 #include <iostream>
 
+// Attention!
+// La definition et l'implementation des classes sont dans le meme fichier,
+// car ce sont des classes TEMPLATE, en consequence on peut pas diviser
+// le definition et l'implementation en deux fichiers.
+
+//====================== Key Definition ===========================
 template<class T>
 class Key {
 	private:
 		T value;
-		bool empty;
-		unsigned int try_count;
+		bool empty; // Indique si 'value' est vide ou pas
+		unsigned int try_count; // Le nombre d'essais lors de l'insertion (0 a la declaration)
 
 	public:
+		// Constructeurs
 		Key();
 		Key(const T& value);
 
+		// Resultat: La cle stockee dans la variable 'value' de la classe.
 		T get() const;
+
+		// Postcondition: La cle est initialisee ou mise a jour par la valeur 'value'.
 		void set(const T& value);
 
+		// Resultat: True si la cle Key ne contient pas de valeur,
+		//			 False sinon.
 		bool isEmpty() const;
 
+		// Resultat: Retourne la cle Key affectee.
+		// Postcondition: La cle est initialisee ou mise a jour par la valeur 'key'.
 		Key<T>& operator=(const Key<T>& key);
 		Key<T>& operator=(const T& key);
 
+		// Resultat: True si les clefs des deux Key sont identiques,
+		//			 False sinon.
 		bool operator==(const Key<T>& key) const;
 		bool operator==(const T& key) const;
 
+		// Resultat: True si les clefs des deux Key ne sont pas identiques,
+		//			 False sinon.
 		bool operator!=(const Key<T>& key) const;
 		bool operator!=(const T& key) const;
 
+		// Resultat: Le nombre d'essais d'insertion
 		unsigned int get_try_count() const;
+
+		// Postcondition: Le nombre d'essais d'insertion et mis a jour par 'nb'
 		void set_try_count(unsigned int nb);
 
+		// Fonction de hachage pour 'k' de type nombre
+		// Resultat: Retourne le reste de la division de 'size' par 'k'
 		static unsigned int hash_modulo (const T& k, unsigned int size);
+
+		// Fonction de rehachage pour 'k' de type nombre
+		// Resultat: Retourne 1, que l'on apres va ajouter a l'index
 		static unsigned int rehash_linear (const T& k, unsigned int try_nb);
 
+		// Surcharhe de l'operateur '<<'
 		friend std::ostream& operator<<(std::ostream& output, const Key<T>& k) { 
 			output << k.value;
 			return output;
 		}
 
+		// Surcharhe de l'operateur '>>'
 		friend std::istream& operator>>(std::istream& input, Key<T>& k) {
 			input >> k.value;
 			return input;
 		}
 };
 
+//====================== Key Implementation ===========================
 template<class T>
 Key<T>::Key() : empty(true), try_count(0) {}
 
diff --git a/tp5/TableDeHachage/src/table.h b/tp5/TableDeHachage/src/table.h
index 64091e9..cd72b4e 100644
--- a/tp5/TableDeHachage/src/table.h
+++ b/tp5/TableDeHachage/src/table.h
@@ -1,3 +1,5 @@
+// Eldar Kasmamytov
+
 #ifndef _TABLE
 #define _TABLE
 
@@ -5,6 +7,11 @@
 #include "key.h"
 #include "info.h"
 
+// Attention!
+// La definition et l'implementation des classes sont dans le meme fichier,
+// car ce sont des classes TEMPLATE, en consequence on peut pas diviser
+// le definition et l'implementation en deux fichiers.
+
 template<class K, class I>
 class Table;
 
@@ -16,17 +23,23 @@ class Case {
 	private:
 		Key<K> key;
 		Info<I> info;
-		bool free;
+		bool free;	// Indique si la case est libre ou pas
 
 	public:
 		Case();
 		Case(const Key<K>& k);
 
+		// Resultat: cle contenue dans la case.
 		Key<K> get_key() const;
+
+		// Resultat: info contenu dans la case.
 		Info<I> get_info() const;
 
+		// Resultat: True si la case est libre,
+		//			 False sinon.
 		bool isFree() const;
 
+		// Postcondition: L'etat interne de la case est affiche dans le terminal.
 		void draw() const;
 };
 
@@ -63,39 +76,65 @@ class Table {
 	private:
 		Case<K,I>* elements;
 
-		unsigned int max_elements;
-		unsigned int nb_elements;
+		unsigned int max_elements; // Le nombre maximum d'elements qu'on peut inserer (taille de la Table)
+		unsigned int nb_elements; // Le nombre effectif d'elements presents dans la Table
 
 		unsigned int (*hash)(const K&, unsigned int);
 		unsigned int (*rehash)(const K&, unsigned int);
 
 	public:
+		// Preconditions: * size=taille de la Table a creer
+		//				  * hash=pointeur vers la fonction de hachage
+		//					(Key<K>::hash_modulo par defaut)
+		//				  * rehash=pointeur vers la fonction de rehachage
+		//					(Key<K>::rehash_linear par defaut)
 		Table(unsigned int size,
 		      unsigned int (*hash)(const K&, unsigned int)=Key<K>::hash_modulo,
 		      unsigned int (*rehash)(const K&, unsigned int)=Key<K>::rehash_linear);
 		~Table();
 
+		// Preconditions: hash=pointeur vers la fonction de hachage
+		// Postcondition: hash est affecte a la donnee membre hash
 		void set_hash(unsigned int (*hash)(const K&, unsigned int));
+
+		// Preconditions: rehash=pointeur vers la fonction de rehachage
+		// Postcondition: rehash est affecte a la donnee membre rehash
 		void set_rehash(unsigned int (*rehash)(const K&, unsigned int));
 
+		// Preconditions: * La taille effective de la Table doit etre inferieure
+		//					a la taille maximale,
+		//					sinon le reste du code n'est pas execute (assert)
+		//				  * Key doit etre unique,
+		//					sinon le reste du code n'est pas execute (assert)
+		// Postcondition: 'key' et 'info' sont inseres dans la case, dont
+		//				  l'indexe est calcule par la fonction 'hash'
 		void add(const K& key, const I& info);
 		void add(const K& key, const Info<I>& info);
 		void add(const Key<K>& key, const Info<I>& info);
 		void add(const Key<K>& key, const I& info);
 
+		// Resultat: L'information associee a la cle 'key'
 		Info<I> get_info(const K& key) const;
 		Info<I> get_info(const Key<K>& key) const;
 
+		// Postcondition: L'information associee a la cle 'key'
+		//				  est mise a jour avec 'info'
 		void set_info(const K& key, const I& info);
 		void set_info(const Key<K>& key, const Info<I>& info);
 
+		// Resultat: L'indexe de la case, dont la cle est identique a 'key'
 		unsigned int find(const K& key) const;
 		unsigned int find(const Key<K>& key) const;
 
+		// Postcondition: La case dont la cle est 'key'
+		//				  est liberee
 		void remove(const K& key);
 
+		// Resultat: L'information associee a la cle 'key'
 		Info<I> operator[](const K& key) const;
 
+		// Preconditions: extra=afficher ou pas l'information supplementaire
+		// Postcondition: L'etat interne de la Table est affiche dans la console
 		void show(bool extra=false) const;
 
 };
-- 
GitLab