using functionning luke bst

Makefile

@@ -32,7 +32,7 @@ RESET    = "\e[0m"
 
 NAME          = containers
 
-CC            = clang++
+CC            = g++
 EXT           = cpp
 
 CFLAGS        = -Wall -Wextra -Werror $(INCLUDES)
@@ -67,11 +67,17 @@ HEADERS       = colors.h \
 				equal.hpp \
 				lexicographical_compare.hpp \
 				pair.hpp \
+				bst.hpp \
+				bst_node.hpp \
+				bst_iterator.hpp \
 				\
-				vector.hpp
+				vector.hpp \
+				map.hpp
 
 D_TEMPLATES   = ./templates
-TEMPLATES     = vector.tpp \
+TEMPLATES     = bst.tpp \
+				\
+				vector.tpp \
 				map.tpp
 
 D_TESTS       = ./tests/includes

headers/bst.hpp

@@ -0,0 +1,148 @@
+#ifndef BST_HPP
+# define BST_HPP
+
+# include <memory> // std::allocator
+# include <cstddef> // NULL, size_t, ptrdiff_t
+# include <algorithm> // max()
+# include <functional> // std::less()
+
+# include "reverse_iterator.hpp"
+# include "equal.hpp"
+# include "lexicographical_compare.hpp"
+
+# include "pair.hpp"
+# include "bst_node.hpp"
+# include "bst_iterator.hpp"
+
+namespace ft {
+
+template <
+	typename Key,
+	typename T,
+	typename Compare = std::less<Key>,
+	typename Allocator = std::allocator< ft::pair<const Key, T> >
+> class Bst
+{
+	public:
+		typedef Key					key_type;
+		typedef T					mapped_type;
+		typedef pair<const Key, T>	value_type;
+		typedef Compare				key_compare;
+		typedef Allocator			allocator_type;
+		typedef std::size_t			size_type;
+		typedef std::ptrdiff_t		difference_type;
+
+		typedef typename Allocator::pointer			pointer;
+		typedef typename Allocator::const_pointer	const_pointer;
+		typedef typename Allocator::reference		reference;
+		typedef typename Allocator::const_reference	const_reference;
+
+
+		typedef Bst_iterator<Key, T, Compare, Allocator>		iterator;
+		typedef Bst_const_iterator<Key, T, Compare, Allocator>	const_iterator;
+		typedef ft::reverse_iterator<iterator>					reverse_iterator;
+		typedef ft::reverse_iterator<const_iterator>			const_reverse_iterator;
+
+
+		// Member functions
+		explicit Bst(const Compare& comp = Compare(), const Allocator& alloc = Allocator() );
+		template < typename InputIt >
+		    Bst(InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator());
+		Bst(const Bst& src);
+		~Bst();
+
+		Bst&	operator=(const Bst& rhs);
+
+		// Element access
+		T&	operator[](const Key& key);
+
+		// Iterators
+		iterator				begin();
+		const_iterator			begin() const;
+		iterator				end();
+		const_iterator			end() const;
+		reverse_iterator		rbegin();
+		const_reverse_iterator	rbegin() const;
+		reverse_iterator		rend();
+		const_reverse_iterator	rend() const;
+
+		// Capacity
+		bool		empty() const;
+		size_type	size() const;
+		size_type	max_size() const;
+
+		// Modifiers
+		void					clear();
+		pair<iterator, bool>	insert(const value_type& value);
+		iterator				insert(iterator hint, const value_type& value);
+		template < typename InputIt >
+		    void				insert(InputIt first, InputIt last);
+		void					erase(iterator pos);
+		void					erase(iterator first, iterator last);
+		size_type				erase(const Key& key);
+		void					swap(Bst& other);
+
+		// Lookup
+		iterator		find(const Key& key);
+		const_iterator	find(const Key& key) const;
+		size_type		count(const Key& key) const;
+
+	private:
+		size_type					_size;
+		node<value_type>*			_root;
+		node_sentinel<value_type>*	_sentinel;
+		Compare						_comp;
+		Allocator					_allocator;
+
+		// TODO : rebind syntaxe pas clair.
+		typename Allocator::template rebind< node<value_type> >::other _allocator_node; // Peu clair, verifier syntaxe
+			typename Allocator::template rebind< node_sentinel<value_type> >::other _allocator_node_sentinel; // Peu clair, verifier syntaxe
+
+		void					_init_sentinel();
+		pair<iterator, bool>	_insert(const value_type& value);
+		node<value_type>*		_erase(iterator pos);
+		node<value_type>*		_subtree_shift(node<value_type>* st_old, node<value_type>* st_new);
+
+		// AVL Balancing
+		void				_insert_rebalancing(node<value_type>* n);
+		void				_erase_rebalancing(node<value_type>* n);
+
+		short				_compute_height(node<value_type>* n);
+		short				_bf(node<value_type>* n); // balance factor
+		node<value_type>*	_rotate_left(node<value_type>* n);
+		node<value_type>*	_rotate_right(node<value_type>* n);
+ };
+
+	// Non-member functions
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		bool    operator==(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		bool    operator!=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		bool    operator<(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		bool    operator>(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		bool    operator<=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		bool    operator>=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
+
+	template < typename Key, typename T, typename Compare, typename Alloc >
+		void    swap(Bst<Key,T,Compare,Alloc>& lhs, Bst<Key,T,Compare,Alloc>& rhs);
+
+} // namespace ft
+
+# include "bst.tpp"
+
+// https://en.wikipedia.org/wiki/Binary_search_tree
+// https://en.wikipedia.org/wiki/AVL_tree
+
+// https://fr.wikipedia.org/wiki/Arbre_binaire_de_recherche
+// https://fr.wikipedia.org/wiki/Arbre_AVL
+
+// https://visualgo.net/en/bst
+// https://visualgo.net/en/bst?slide=14-8 // --> to 14-13
+
+
+#endif
+

headers/bst_iterator.hpp

@@ -0,0 +1,207 @@
+#ifndef BST_ITERATOR_HPP
+# define BST_ITERATOR_HPP
+
+# include <cstddef> // NULL, ptrdiff_t
+# include <iterator> // iterator_tag
+
+# include "pair.hpp"
+# include "bst_node.hpp"
+
+namespace ft {
+
+template <
+	typename Key,
+	typename T,
+	typename Compare,
+	typename Allocator
+> class Bst_iterator
+{
+	private:
+		typedef Bst_iterator	Self;
+
+	public:
+		typedef std::bidirectional_iterator_tag		iterator_category;
+		typedef pair<const Key, T>					value_type;
+		typedef std::ptrdiff_t						difference_type;
+		typedef value_type*							pointer;
+		typedef value_type&							reference;
+
+		Bst_iterator() : _node(), _sentinel() {}
+		Bst_iterator(node<value_type>* n, node_sentinel<value_type>* sentinel) : _node(n), _sentinel(sentinel) {}
+		//Bst_iterator(const Bst_iterator& src) : _node(src._node), _sentinel(src._sentinel) {} //implicit
+
+		reference	operator*() const
+			{ return _node->value; }
+		pointer		operator->() const
+			{ return &_node->value; }
+
+		Self&	operator++()
+		{
+			if (_node == NULL)
+				_node = _sentinel->child->min();
+			else if (_node->right)
+				_node = _node->right->min();
+			else
+			{
+				node<value_type>*	up = _node->up;
+				while (up != NULL && _node == up->right)
+				{
+					_node = up;
+					up = up->up;
+				}
+				_node = up;
+			}
+			return *this;
+		}
+
+		Self&	operator--()
+		{
+			if (_node == NULL)
+				_node = _sentinel->child->max();
+			else if (_node->left)
+				_node = _node->left->max();
+			else
+			{
+				node<value_type>*	up = _node->up;
+				while (up != NULL && _node == up->left)
+				{
+					_node = up;
+					up = up->up;
+				}
+				_node = up;
+			}
+			return *this;
+		}
+		
+		Self	operator++(int)
+		{
+			//Self old(*this);
+			Self old = *this;
+			++(*this);
+			return old;
+		}
+
+		Self	operator--(int)
+		{
+			//Self old(*this);
+			Self old = *this;
+			--(*this);
+			return old;
+		}	
+
+		node<value_type>*	getNode()
+			{ return _node; }
+		const node<value_type>*	getNode() const
+			{ return _node; }
+		const node_sentinel<value_type>*	getSentinel() const
+			{ return _sentinel; }
+
+		// TODO : friend Non-member functions syntaxe pas clair.
+		friend bool operator==(const Self &lhs, const Self &rhs)
+			{ return lhs._node == rhs._node; }
+		friend bool operator!=(const Self &lhs, const Self &rhs)
+			{ return !(lhs._node == rhs._node); }
+
+	private:
+		node<value_type>*			_node;
+		node_sentinel<value_type>*	_sentinel;
+};
+
+template <
+	typename Key,
+	typename T,
+	typename Compare,
+	typename Allocator
+> class Bst_const_iterator
+{
+	private:
+		typedef Bst_const_iterator	Self;
+
+	public:
+		typedef std::bidirectional_iterator_tag		iterator_category;
+		typedef pair<const Key, T>					value_type;
+		typedef std::ptrdiff_t						difference_type;
+		typedef const value_type*					pointer;
+		typedef const value_type&					reference;
+
+		Bst_const_iterator() : _node(), _sentinel() {}
+		Bst_const_iterator(const node<value_type>* node, const node_sentinel<value_type>* sentinel) : _node(node), _sentinel(sentinel) {}
+		//Bst_const_iterator(const Bst_const_iterator& src) : _node(src._node), _sentinel(src._sentinel) {} //implicit
+		Bst_const_iterator(const Bst_iterator<Key, T, Compare, Allocator>& src) : _node(src.getNode()), _sentinel(src.getSentinel()) {}
+
+		reference	operator*() const
+			{ return _node->value; }
+		pointer		operator->() const
+			{ return &_node->value; }
+
+		Self&	operator++()
+		{
+			if (_node == NULL)
+				_node = _sentinel->child->min();
+			else if (_node->right)
+				_node = _node->right->min();
+			else
+			{
+				node<value_type>*	up = _node->up;
+				while (up != NULL && _node == up->right)
+				{
+					_node = up;
+					up = up->up;
+				}
+				_node = up;
+			}
+			return *this;
+		}
+
+		Self&	operator--()
+		{
+			if (_node == NULL)
+				_node = _sentinel->child->max();
+			else if (_node->left)
+				_node = _node->left->max();
+			else
+			{
+				node<value_type>*	up = _node->up;
+				while (up != NULL && _node == up->left)
+				{
+					_node = up;
+					up = up->up;
+				}
+				_node = up;
+			}
+			return *this;
+		}
+		
+		Self	operator++(int)
+		{
+			//Self old(*this);
+			Self old = *this;
+			++(*this);
+			return old;
+		}
+
+		Self	operator--(int)
+		{
+			//Self old(*this);
+			Self old = *this;
+			--(*this);
+			return old;
+		}	
+
+		node<value_type>*	getNode() const
+			{ return _node; }
+
+		friend bool operator==(const Self &lhs, const Self &rhs)
+			{ return lhs._node == rhs._node; }
+		friend bool operator!=(const Self &lhs, const Self &rhs)
+			{ return !(lhs._node == rhs._node); }
+
+	private:
+		const node<value_type>*				_node;
+		const node_sentinel<value_type>*	_sentinel;
+};
+
+} // namespace ft
+
+#endif
+

headers/bst_node.hpp

@@ -0,0 +1,50 @@
+
+#ifndef BST_NODE_HPP
+# define BST_NODE_HPP
+
+# include <cstddef> // NULL
+
+namespace ft {
+
+template < typename ValueType >
+struct node
+{
+	ValueType	value;
+	node		*up;
+	node		*left;
+	node		*right;
+	short		height;
+
+	node(const ValueType& val) : value(val), up(NULL), left(NULL), right(NULL), height(1) {}
+
+	node*	min()
+	{ 
+		node*	n = this;
+
+		while (n->left)
+			n = n->left;
+		return n;
+	}
+
+	node*	max()
+	{ 
+		node*	n = this;
+
+		while (n->right)
+			n = n->right;
+		return n;
+	}
+};
+
+template < typename ValueType >
+struct node_sentinel
+{
+	node<ValueType>	*child;
+
+	node_sentinel() : child(NULL) {}
+};
+
+} // namespace ft
+
+#endif
+

headers/map.hpp

@@ -8,7 +8,7 @@
 # include <functional>	// std::less, std::binary_function
 
 # include "pair.hpp"
-//# include "bst.hpp"
+# include "bst.hpp"
 
 namespace ft {
 
@@ -34,7 +34,7 @@ public:
 //	typedef typename allocator_type::pointer			pointer;
 //	typedef typename allocator_type::const_pointer		const_pointer;
 
-//	typedef Bst<Key,T,Compare,Alloc>					bst_map;
+	typedef Bst<Key,T,Compare,Alloc>					bst_map;
 
 //	typedef typename bst_map::iterator					iterator;
 //	typedef typename bst_map::const_iterator			const_iterator;
@@ -107,7 +107,7 @@ public:
 	 * element access :
 	 ******************/
 //// operator[] --------------------------------
-//	mapped_type &	operator[] (const key_type& k);
+	mapped_type &	operator[] (const key_type& k);
 
 
 	/*************
@@ -166,6 +166,7 @@ private:
 
 	allocator_type	_allocator;
 	key_compare		_comp;
+	bst_map			_bst;
 
 };
 

templates/bst.tpp

@@ -0,0 +1,628 @@
+
+#define BST_TEMPLATE	template < typename Key, typename T, typename Compare, typename Allocator >
+#define BST		Bst<Key, T, Compare, Allocator>
+
+namespace ft {
+
+
+  //////////////////////
+ // Member functions //
+
+BST_TEMPLATE
+BST::
+	Bst(const Compare& comp, const Allocator& alloc) :
+_size(0),
+_root(NULL),
+_comp(comp),
+_allocator(alloc)
+{
+	_init_sentinel();
+}
+
+BST_TEMPLATE
+template < typename InputIt >
+BST::
+	Bst(InputIt first, InputIt last, const Compare& comp, const Allocator& alloc) :
+_size(0),
+_root(NULL),
+_comp(comp),
+_allocator(alloc)
+{
+	_init_sentinel();
+	insert(first, last);
+}
+
+BST_TEMPLATE
+BST::
+	Bst(const Bst& src) :
+_size(0),
+_root(NULL),
+_comp(src._comp),
+_allocator(src._allocator)
+{
+	_init_sentinel();
+	*this = src;
+}
+
+BST_TEMPLATE
+BST::
+	~Bst()
+{
+	clear();
+	_allocator_node_sentinel.destroy(_sentinel);
+	_allocator_node_sentinel.deallocate(_sentinel, 1);	
+}
+
+BST_TEMPLATE
+BST&	BST::
+	operator=(const Bst& rhs)
+{
+	if (this == &rhs)
+		return (*this);
+	Bst	new_bst(rhs.begin(), rhs.end());
+	swap(new_bst);
+	return (*this);
+}
+
+
+  ////////////////////
+ // Element access //
+
+BST_TEMPLATE
+T&	BST::
+	operator[](const Key& key)
+{
+	node<value_type>*	n = _root;
+	//node<value_type>*	prev = NULL;
+
+	while (n)
+	{
+		//prev = n;
+		if (_comp(key, n->value.first))
+			n = n->left;
+		else if (_comp(n->value.first, key))
+			n = n->right;
+		else
+			return (n->value.second);
+	}
+
+	// TODO : Call insert with hint (prev)
+	n = insert( ft::make_pair(key, mapped_type()) ).first.getNode();
+
+	return (n->value.second);
+}
+
+
+  ///////////////
+ // Iterators //
+
+BST_TEMPLATE
+typename BST::iterator	BST::
+	begin()
+{
+	if (_root)
+		return iterator(_root->min(), _sentinel);
+	else
+		return end();
+}
+
+BST_TEMPLATE
+typename BST::const_iterator	BST::
+	begin() const
+{ 
+	if (_root)
+		return const_iterator(_root->min(), _sentinel);
+	else
+		return end();
+}
+
+BST_TEMPLATE
+typename BST::iterator	BST::
+	end() { return iterator(NULL, _sentinel); }
+
+BST_TEMPLATE
+typename BST::const_iterator	BST::
+	end() const { return const_iterator(NULL, _sentinel); }
+
+BST_TEMPLATE
+typename BST::reverse_iterator	BST::
+	rbegin() { return reverse_iterator(end()); }
+
+BST_TEMPLATE
+typename BST::const_reverse_iterator	BST::
+	rbegin() const { return const_reverse_iterator(end()); }
+
+BST_TEMPLATE
+typename BST::reverse_iterator	BST::
+	rend() { return reverse_iterator(begin()); }
+
+BST_TEMPLATE
+typename BST::const_reverse_iterator	BST::
+	rend() const { return const_reverse_iterator(begin()); }
+
+
+  //////////////
+ // Capacity //
+
+BST_TEMPLATE
+bool	BST::	
+	empty() const { return (_size == 0); }
+
+BST_TEMPLATE
+typename BST::size_type		BST::
+	size() const { return (_size); }
+
+BST_TEMPLATE
+typename BST::size_type		BST::
+	max_size() const
+{
+	return ( _allocator_node.max_size() );
+}
+
+
+  ///////////////
+ // Modifiers //
+
+BST_TEMPLATE
+void	BST::
+	clear()
+{
+	// TODO : optimisation jouable ?
+	erase(begin(), end());
+	//_size = 0;
+}
+
+BST_TEMPLATE
+pair<typename BST::iterator, bool>	BST::
+	insert(const value_type& value)
+{
+	pair<typename BST::iterator, bool>	ret;
+	
+	ret = _insert(value);
+	if (ret.second == true)
+		_insert_rebalancing(ret.first.getNode()->up);
+	return (ret);
+}
+
+BST_TEMPLATE
+typename BST::iterator	BST::
+	insert(iterator hint, const value_type& value)
+{
+	// TODO : optimise with hint
+	(void)hint;
+	return insert(value).first;
+}
+
+BST_TEMPLATE
+template < typename InputIt >
+void	BST::
+	insert(InputIt first, InputIt last)
+{
+	//static int i = 0; // Debug
+	while (first != last)
+	{
+		insert(*first);
+		++first;
+		//std::cout << "c|" << i << "\n";
+		//++i;
+	}
+}
+
+BST_TEMPLATE
+void	BST::
+	erase(iterator pos)
+{
+	node<value_type>*	delete_point;
+	delete_point = _erase(pos);
+	_erase_rebalancing(delete_point);
+}
+
+BST_TEMPLATE
+void	BST::
+	erase(iterator first, iterator last)
+{
+	while (first != last)
+		erase(first++);
+}
+
+BST_TEMPLATE
+typename BST::size_type		BST::
+	erase(const Key& key)
+{
+	iterator	pos = find(key);
+	if (pos == end())
+		return (0);
+	else
+	{
+		erase(pos);
+		return (1);
+	}
+}
+
+BST_TEMPLATE
+void		BST::
+	swap(Bst& other)
+{
+	node<value_type>*	tmp_root = _root;
+	node_sentinel<value_type>*	tmp_sentinel = _sentinel;
+	size_type			tmp_size = _size;
+
+	_root = other._root;
+	_sentinel = other._sentinel;
+	_size = other._size;
+
+	other._root = tmp_root;
+	other._sentinel = tmp_sentinel;
+	other._size = tmp_size;
+}
+
+
+  ////////////
+ // Lookup //
+
+BST_TEMPLATE
+typename BST::iterator	BST::
+	find(const Key& key)
+{
+	node<value_type>*	n = _root;
+
+	while (n)
+	{
+		if (_comp(key, n->value.first))
+			n = n->left;
+		else if (_comp(n->value.first, key))
+			n = n->right;
+		else
+			return (iterator(n, _sentinel));
+	}
+	return (end());
+}
+
+BST_TEMPLATE
+typename BST::const_iterator	BST::
+	find(const Key& key) const
+{
+	node<value_type>*	n = _root;
+
+	while (n)
+	{
+		if (_comp(key, n->value.first))
+			n = n->left;
+		else if (_comp(n->value.first, key))
+			n = n->right;
+		else
+			return (const_iterator(n, _sentinel));
+	}
+	return (end());
+}
+
+BST_TEMPLATE
+typename BST::size_type		BST::
+	count(const Key& key) const
+{
+	if (find(key) != end())
+		return (1);
+	else
+		return (0);
+}
+
+
+  ///////////////////////
+ // Private functions //
+
+BST_TEMPLATE
+void	BST::
+	_init_sentinel()
+{
+	_sentinel = _allocator_node_sentinel.allocate(1);
+	_allocator_node_sentinel.construct(_sentinel, node_sentinel<value_type>());
+}
+
+BST_TEMPLATE
+pair<typename BST::iterator, bool>	BST::
+	_insert(const value_type& value)
+{
+	node<value_type>*	n = _root;
+	node<value_type>*	prev = NULL;
+
+	while (n)
+	{
+		prev = n;
+		if (_comp(value.first, n->value.first))
+			n = n->left;
+		else if (_comp(n->value.first, value.first))
+			n = n->right;
+		else
+			return ft::make_pair(iterator(n, _sentinel), false);
+	}
+
+	n = _allocator_node.allocate(1);
+	_allocator_node.construct(n, node<value_type>(value));
+	if (_root == NULL) // if (_size == 0)
+	{
+		_root = n;
+		_sentinel->child = _root;
+	}
+	else if (_comp(value.first, prev->value.first))
+		prev->left = n;
+	else
+		prev->right = n;
+	n->up = prev;
+	++_size;
+	return ft::make_pair(iterator(n, _sentinel), true);
+}
+
+BST_TEMPLATE
+node<typename BST::value_type>*	BST::
+	_erase(iterator pos)
+{
+	node<value_type>*	n = pos.getNode();
+	node<value_type>*	delete_point = NULL;
+
+	if (n->left && n->right) // 2 child
+	{
+		node<value_type>*	next = n->right->min();
+
+		if (next->up != n)
+		{
+			_subtree_shift(next, next->right);
+			next->right = n->right;
+			next->right->up = next;
+		}
+		delete_point = _subtree_shift(n, next);
+		next->left = n->left;
+		next->left->up = next;
+	}
+	else if (!n->left && !n->right) // no child (leaf)
+		delete_point = _subtree_shift(n, NULL); // bug ?
+	else if (n->left) // 1 child
+		delete_point = _subtree_shift(n, n->left);
+	else if (n->right) // 1 child
+		delete_point = _subtree_shift(n, n->right); // bug ?
+	
+	_allocator_node.destroy(n);
+	_allocator_node.deallocate(n, 1);
+	--_size;
+	return (delete_point);
+}
+
+BST_TEMPLATE
+node<typename BST::value_type>*	BST::
+	_subtree_shift(node<value_type>* st_old, node<value_type>* st_new)
+{
+	node<value_type>*	p = st_old->up;
+
+	if (st_old == _root)
+	{	
+		_root = st_new;
+		_sentinel->child = _root;
+	}
+	else if (st_old == p->left)
+		p->left = st_new;
+	else
+		p->right = st_new;
+	
+	if (st_new == NULL)
+		return (p); // return deletion point
+	st_new->up = p;
+	return (st_new); // return deletion point
+}
+
+BST_TEMPLATE
+void	BST::
+	_insert_rebalancing(node<value_type>* n)
+{
+	node<value_type>*	old_n;
+	node<value_type>*	parent = NULL;
+
+	while (n)
+	{
+		n->height = _compute_height(n);
+
+		if (_bf(n) > 1) // Left Heavy
+		{
+			parent = n->up;
+			if (_bf(n->left) < 0) // Left-Right Case (BF == -1)
+				n->left = _rotate_left(n->left);
+			// Left-Left Case
+			n = _rotate_right(n);
+			old_n = n->right;
+		}
+		else if (_bf(n) < -1) // Right Heavy
+		{
+			parent = n->up;
+			if (_bf(n->right) > 0) // Right-Left Case (BF == 1)
+				n->right = _rotate_right(n->right);
+			// Right-Right Case
+			n = _rotate_left(n);
+			old_n = n->left;
+		}
+
+		if (parent)
+		{
+			if (parent->left == old_n)
+				parent->left = n;
+			else
+				parent->right = n;
+			break;
+		}
+
+		n = n->up;
+	}
+
+	while (n)
+	{
+		n->height = _compute_height(n);
+		n = n->up;
+	}
+}
+
+BST_TEMPLATE
+void	BST::
+	_erase_rebalancing(node<value_type>* n)
+{
+	node<value_type>*	old_n;
+	node<value_type>*	parent = NULL;
+	
+	while (n)
+	{
+		n->height = _compute_height(n);
+
+		if (_bf(n) > 1) // Left Heavy
+		{
+			parent = n->up;
+			if (_bf(n->left) < 0) // Left-Right Case (BF == -1)
+				n->left = _rotate_left(n->left);
+			// Left-Left Case
+			n = _rotate_right(n);
+			old_n = n->right;
+		}
+		else if (_bf(n) < -1) // Right Heavy
+		{
+			parent = n->up;
+			if (_bf(n->right) > 0) // Right-Left Case (BF == 1)
+				n->right = _rotate_right(n->right);
+			// Right-Right Case
+			n = _rotate_left(n);
+			old_n = n->left;
+		}
+
+		if (parent)
+		{
+			if (parent->left == old_n)
+				parent->left = n;
+			else
+				parent->right = n;
+			parent = NULL;
+		}
+
+		n = n->up;
+	}
+}
+
+BST_TEMPLATE
+short	BST::
+	_compute_height(node<value_type>* n)
+{
+	if (n->left && n->right)
+		return std::max(n->left->height, n->right->height) + 1;
+	else if (n->left)
+		return n->left->height + 1;
+	else if (n->right)
+		return n->right->height + 1;
+	else
+		return 1;
+}
+
+BST_TEMPLATE
+short	BST::
+	_bf(node<value_type>* n) // optimisation possible if assume n have at least one child ?
+{
+	if (n->left && n->right)
+		return n->left->height - n->right->height;
+	else if (n->left)
+		return n->left->height;
+	else if (n->right)
+		return (-(n->right->height));
+	else
+		return 0;
+}
+
+BST_TEMPLATE
+node<typename BST::value_type>*		BST::
+	_rotate_left(node<value_type>* n) // assume n->right != NULL
+{
+	node<value_type>*	ori_right = n->right;
+
+	ori_right->up = n->up;
+	n->up = ori_right;
+
+	n->right = ori_right->left;
+	if (n->right != NULL)
+		n->right->up = n;
+	ori_right->left = n;
+
+	n->height = _compute_height(n);
+	ori_right->height = _compute_height(ori_right);
+
+	if (n == _root)
+	{
+		_root = ori_right;
+		_sentinel->child = _root;
+	}
+
+	return ori_right; // return new sub-tree root
+}
+
+BST_TEMPLATE
+node<typename BST::value_type>*		BST::
+	_rotate_right(node<value_type>* n) // assume n->left != NULL
+{
+	node<value_type>*	ori_left = n->left;
+
+	ori_left->up = n->up;
+	n->up = ori_left;
+	
+	n->left = ori_left->right;
+	if (n->left != NULL)
+		n->left->up = n;
+	ori_left->right = n;
+
+	n->height = _compute_height(n);
+	ori_left->height = _compute_height(ori_left);
+
+	if (n == _root)
+	{
+		_root = ori_left;
+		_sentinel->child = _root;
+	}
+
+	return ori_left; // return new sub-tree root
+}
+
+
+  //////////////////////////
+ // Non-member functions //
+
+BST_TEMPLATE
+bool	operator==(const BST& lhs, const BST& rhs)
+{
+	if (lhs.size() != rhs.size())
+		return false;
+	return ft::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+BST_TEMPLATE
+bool	operator!=(const BST& lhs, const BST& rhs)
+	{ return !(lhs == rhs); }
+
+
+BST_TEMPLATE
+bool	operator<(const BST& lhs, const BST& rhs)
+{
+	return ft::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+BST_TEMPLATE
+bool	operator>(const BST& lhs, const BST& rhs)
+	{ return (rhs < lhs); }
+
+BST_TEMPLATE
+bool	operator<=(const BST& lhs, const BST& rhs)
+	{ return !(lhs > rhs); }
+
+BST_TEMPLATE
+bool	operator>=(const BST& lhs, const BST& rhs)
+	{ return !(lhs < rhs); }
+
+
+BST_TEMPLATE
+void	swap(BST& lhs, BST& rhs)
+	{ lhs.swap(rhs); }
+
+
+} // namespace ft
+
+#undef BST
+#undef BST_TEMPLATE
+

templates/map.tpp

@@ -61,7 +61,11 @@ MP_TPL MP::
 	 * element access :
 	 ******************/
 //// operator[] --------------------------------
-//	mapped_type &	operator[] (const key_type& k);
+MP_TPL typename MP::mapped_type& MP::
+	operator[] (const key_type& k) {
+
+	return _bst[k];
+}
 
 
 	/*************

tests/tests_map.cpp

@@ -10,10 +10,11 @@ TEST_M(tests_map_simple)
 	TITLE(simple test)
 
 	typename ft::map<T, U>				mp;
-//	typename std::map<T, U>::iterator	it;
+	typename std::map<T, U>::iterator	it;
-//
+
-//	mp[VALT('a')] = VALU(10);
+	mp[VALT('a')] = VALU(10);
-//
+
+//	it = mp.begin();
 //	PRINT(mp)
 
 	DELETE