149 lines
4.9 KiB
C++
149 lines
4.9 KiB
C++
#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
|
|
|