small clean up of the files
This commit is contained in:
hugogogo
@@ -1,187 +0,0 @@
|
||||
#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 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;
|
||||
|
||||
|
||||
/************
|
||||
* copliens :
|
||||
************/
|
||||
// constructors ------------------------------
|
||||
explicit Bst(
|
||||
const key_compare& comp = Compare(),
|
||||
const Allocator& alloc = Allocator()
|
||||
);
|
||||
template < typename InputIt >
|
||||
Bst(
|
||||
InputIt first, InputIt last,
|
||||
const key_compare& comp = Compare(),
|
||||
const allocator_type& alloc = Allocator()
|
||||
);
|
||||
Bst(const Bst& src);
|
||||
// destructor --------------------------------
|
||||
~Bst();
|
||||
// operator= ---------------------------------
|
||||
Bst& operator=(const Bst& rhs);
|
||||
|
||||
|
||||
/*************
|
||||
* iterators :
|
||||
*************/
|
||||
// begin -------------------------------------
|
||||
iterator begin();
|
||||
const_iterator begin() const;
|
||||
// end ---------------------------------------
|
||||
iterator end();
|
||||
const_iterator end() const;
|
||||
// rbegin ------------------------------------
|
||||
reverse_iterator rbegin();
|
||||
const_reverse_iterator rbegin() const;
|
||||
// rend --------------------------------------
|
||||
reverse_iterator rend();
|
||||
const_reverse_iterator rend() const;
|
||||
|
||||
|
||||
/************
|
||||
* capacity :
|
||||
************/
|
||||
// empty -------------------------------------
|
||||
bool empty() const;
|
||||
// size --------------------------------------
|
||||
size_type size() const;
|
||||
// max_size ----------------------------------
|
||||
size_type max_size() const;
|
||||
|
||||
|
||||
/******************
|
||||
* element access :
|
||||
******************/
|
||||
// operator[] --------------------------------
|
||||
mapped_type& operator[](const key_type& key);
|
||||
|
||||
|
||||
/*************
|
||||
* modifiers :
|
||||
*************/
|
||||
// insert ------------------------------------
|
||||
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);
|
||||
// erase -------------------------------------
|
||||
void erase(iterator pos);
|
||||
size_type erase(const key_type& key);
|
||||
void erase(iterator first, iterator last);
|
||||
// swap --------------------------------------
|
||||
void swap(Bst& other);
|
||||
// clear -------------------------------------
|
||||
void clear();
|
||||
|
||||
/**************
|
||||
* operations :
|
||||
**************/
|
||||
// find --------------------------------------
|
||||
iterator find(const key_type& key);
|
||||
const_iterator find(const key_type& key) const;
|
||||
// count -------------------------------------
|
||||
size_type count(const key_type& key) const;
|
||||
|
||||
private:
|
||||
size_type _size;
|
||||
node<value_type>* _root;
|
||||
node_sentinel<value_type>* _sentinel;
|
||||
Compare _comp;
|
||||
Allocator _allocator;
|
||||
|
||||
// https://stackoverflow.com/questions/14148756/what-does-template-rebind-do
|
||||
typename Allocator::template
|
||||
rebind< node<value_type> >::other _allocator_node;
|
||||
typename Allocator::template
|
||||
rebind< node_sentinel<value_type> >::other _allocator_node_sentinel;
|
||||
|
||||
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
|
||||
);
|
||||
|
||||
// BBST
|
||||
// https://www.youtube.com/watch?v=vRwi_UcZGjU
|
||||
void _insert_rebalancing(node<value_type>* n);
|
||||
void _erase_rebalancing(node<value_type>* n);
|
||||
|
||||
short _compute_height(node<value_type>* n);
|
||||
short _balance_factor(node<value_type>* n);
|
||||
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
|
||||
|
||||
@@ -1,207 +0,0 @@
|
||||
#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
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
|
||||
#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
|
||||
|
||||
@@ -1,207 +0,0 @@
|
||||
|
||||
#ifndef MAP_HPP
|
||||
# define MAP_HPP
|
||||
|
||||
# include <memory> // std::allocator
|
||||
# include <cstddef> // NULL, std::size_t, std::ptrdiff_t
|
||||
# include <functional> // std::less, std::binary_function
|
||||
|
||||
# include "pair.hpp"
|
||||
# include "bst.hpp"
|
||||
|
||||
namespace ft {
|
||||
|
||||
template <
|
||||
class Key, // map::key_type
|
||||
class T, // map::mapped_type
|
||||
class Compare = std::less<Key>, // map::key_compare
|
||||
class Alloc = std::allocator< ft::pair<const Key, T> > // map::allocator_type
|
||||
> class map {
|
||||
|
||||
public:
|
||||
|
||||
typedef Key key_type;
|
||||
typedef T mapped_type;
|
||||
typedef pair<const Key, T> value_type;
|
||||
typedef std::size_t size_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef Compare key_compare;
|
||||
typedef Alloc allocator_type;
|
||||
|
||||
typedef Bst<Key,T,Compare,Alloc> bst_map;
|
||||
|
||||
typedef typename bst_map::iterator iterator;
|
||||
typedef typename bst_map::const_iterator const_iterator;
|
||||
typedef typename bst_map::reverse_iterator reverse_iterator;
|
||||
typedef typename bst_map::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
|
||||
/****************
|
||||
* member class :
|
||||
****************/
|
||||
// https://en.cppreference.com/w/cpp/container/map/value_compare
|
||||
// https://stackoverflow.com/questions/4571355/why-would-one-use-nested-classes-in-c
|
||||
class value_compare : public std::binary_function<value_type, value_type, bool> {
|
||||
|
||||
friend class map;
|
||||
protected:
|
||||
Compare comp;
|
||||
value_compare(Compare c) : comp(c) {}
|
||||
public:
|
||||
bool operator() (const value_type& x, const value_type& y) const
|
||||
{ return comp(x.first, y.first); }
|
||||
};
|
||||
|
||||
|
||||
/************
|
||||
* copliens :
|
||||
************/
|
||||
// constructors ------------------------------
|
||||
explicit map (const key_compare& comp = key_compare(),
|
||||
const allocator_type& alloc = allocator_type());
|
||||
template <class InputIterator>
|
||||
map (InputIterator first, InputIterator last,
|
||||
const key_compare& comp = key_compare(),
|
||||
const allocator_type& alloc = allocator_type());
|
||||
map (const map& x);
|
||||
// destructor --------------------------------
|
||||
~map();
|
||||
// operator= ---------------------------------
|
||||
map& operator= (const map& x);
|
||||
|
||||
|
||||
/*************
|
||||
* iterators :
|
||||
*************/
|
||||
// begin -------------------------------------
|
||||
iterator begin();
|
||||
const_iterator begin() const;
|
||||
// end ---------------------------------------
|
||||
iterator end();
|
||||
const_iterator end() const;
|
||||
// rbegin ------------------------------------
|
||||
reverse_iterator rbegin();
|
||||
const_reverse_iterator rbegin() const;
|
||||
// rend --------------------------------------
|
||||
reverse_iterator rend();
|
||||
const_reverse_iterator rend() const;
|
||||
|
||||
|
||||
/************
|
||||
* capacity :
|
||||
************/
|
||||
// empty -------------------------------------
|
||||
bool empty() const;
|
||||
// size --------------------------------------
|
||||
size_type size() const;
|
||||
// max_size ----------------------------------
|
||||
size_type max_size() const;
|
||||
|
||||
|
||||
/******************
|
||||
* element access :
|
||||
******************/
|
||||
// operator[] --------------------------------
|
||||
mapped_type & operator[] (const key_type& k);
|
||||
|
||||
|
||||
/*************
|
||||
* modifiers :
|
||||
*************/
|
||||
// insert ------------------------------------
|
||||
pair<iterator,bool> insert (const value_type& val);
|
||||
iterator insert (iterator position, const value_type& val);
|
||||
template <class InputIterator>
|
||||
void insert (InputIterator first, InputIterator last);
|
||||
// erase -------------------------------------
|
||||
void erase (iterator position);
|
||||
size_type erase (const key_type& k);
|
||||
void erase (iterator first, iterator last);
|
||||
// swap --------------------------------------
|
||||
void swap (map& x);
|
||||
// clear -------------------------------------
|
||||
void clear();
|
||||
|
||||
|
||||
/*************
|
||||
* observers :
|
||||
*************/
|
||||
// key_comp ----------------------------------
|
||||
key_compare key_comp() const;
|
||||
// value_comp --------------------------------
|
||||
value_compare value_comp() const;
|
||||
|
||||
|
||||
/**************
|
||||
* operations :
|
||||
**************/
|
||||
// find --------------------------------------
|
||||
iterator find (const key_type& k);
|
||||
const_iterator find (const key_type& k) const;
|
||||
// count -------------------------------------
|
||||
size_type count (const key_type& k) const;
|
||||
// lower_bound -------------------------------
|
||||
iterator lower_bound (const key_type& k);
|
||||
const_iterator lower_bound (const key_type& k) const;
|
||||
// upper_bound -------------------------------
|
||||
iterator upper_bound (const key_type& k);
|
||||
const_iterator upper_bound (const key_type& k) const;
|
||||
// equal_range -------------------------------
|
||||
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
|
||||
pair<iterator,iterator> equal_range (const key_type& k);
|
||||
|
||||
|
||||
/*************
|
||||
* allocator :
|
||||
*************/
|
||||
// get_allocator -----------------------------
|
||||
allocator_type get_allocator() const;
|
||||
|
||||
// TMP non privat
|
||||
bst_map _bst;
|
||||
private:
|
||||
|
||||
allocator_type _allocator;
|
||||
key_compare _comp;
|
||||
|
||||
};
|
||||
|
||||
|
||||
/************************
|
||||
* non-member functions :
|
||||
************************/
|
||||
// operator == -------------------------------
|
||||
template< class K, class T, class Comp, class Alloc > bool operator==
|
||||
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
|
||||
// operator != -------------------------------
|
||||
template< class K, class T, class Comp, class Alloc > bool operator!=
|
||||
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
|
||||
// operator < --------------------------------
|
||||
template< class K, class T, class Comp, class Alloc > bool operator<
|
||||
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
|
||||
// operator <= -------------------------------
|
||||
template< class K, class T, class Comp, class Alloc > bool operator<=
|
||||
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
|
||||
// operator > --------------------------------
|
||||
template< class K, class T, class Comp, class Alloc > bool operator>
|
||||
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
|
||||
// operator >= -------------------------------
|
||||
template< class K, class T, class Comp, class Alloc > bool operator>=
|
||||
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
|
||||
// swap (map) -----------------------------
|
||||
template< class Key, class T, class Compare, class Alloc > void swap
|
||||
( std::map<Key,T,Compare,Alloc>& lhs, std::map<Key,T,Compare,Alloc>& rhs );
|
||||
|
||||
|
||||
} // namespace ft
|
||||
|
||||
# include "map.tpp"
|
||||
|
||||
// banlanced binary search tree :
|
||||
// https://www.youtube.com/watch?v=vRwi_UcZGjU
|
||||
|
||||
// entinel node :
|
||||
// https://en.wikipedia.org/wiki/Sentinel_node
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user