42/42_INT_11_ft_containers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

stack almost good

Browse Source
This commit is contained in:
hugogogo
2022-06-24 02:23:53 +02:00
parent 58d417742b
commit 6617d6cdf5
23 changed files with 3137 additions and 1081 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
headers/map.hpp
View File

@@ -4,7 +4,7 @@
# include <memory> // std::allocator
# include <cstddef> // NULL, std::size_t, std::ptrdiff_t
# include <algorithm> // max()
# include <algorithm> // std::max()
# include <functional> // std::less, std::binary_function
# include "reverse_iterator.hpp"
@@ -22,27 +22,29 @@ template <
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 Compare key_compare;
typedef Alloc allocator_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
> class map {
// typedef typename Alloc::pointer pointer;
// typedef typename Alloc::const_pointer const_pointer;
// typedef typename Alloc::reference reference;
// typedef typename Alloc::const_reference const_reference;
public:
typedef map_iterator<Key, T, Compare, Alloc> iterator;
typedef map_const_iterator<Key, T, Compare, Alloc> const_iterator;
typedef ft::reverse_iterator<iterator> reverse_iterator;
typedef ft::reverse_iterator<const_iterator> const_reverse_iterator;
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 map_iterator<Key, T, Compare, Alloc> iterator;
typedef map_const_iterator<Key, T, Compare, Alloc> const_iterator;
typedef ft::reverse_iterator<iterator> reverse_iterator;
typedef ft::reverse_iterator<const_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;
@@ -54,105 +56,172 @@ template <
{ return comp(x.first, y.first); }
};
// Member functions
explicit map(const Compare& comp = Compare(), const Alloc& alloc = Alloc() );
template < typename InputIt >
map(InputIt first, InputIt last, const Compare& comp = Compare(), const Alloc& alloc = Alloc());
map(const map& src);
~map();
map& operator=(const map& rhs);
/************
* 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);
// 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;
/*************
* 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
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(map& other);
/************
* capacity :
************/
// empty -------------------------------------
bool empty() const;
// size --------------------------------------
size_type size() const;
// max_size ----------------------------------
size_type max_size() const;
// 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;
Alloc _allocator;
/******************
* element access :
******************/
// operator[] --------------------------------
mapped_type & operator[] (const key_type& k);
// TODO : rebind syntaxe pas clair.
typename Alloc::template rebind< node<value_type> >::other _allocator_node; // Peu clair, verifier syntaxe
typename Alloc::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);
/*************
* 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();
// 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);
/*************
* 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;
private:
size_type _size;
node<value_type>* _root;
node_sentinel<value_type>* _sentinel;
Compare _comp;
Alloc _allocator;
// https://stackoverflow.com/questions/14148756/what-does-template-rebind-do
typename Alloc::template rebind< node<value_type> >::other _allocator_node; // Peu clair, verifier syntaxe
typename Alloc::template rebind< node_sentinel<value_type> >::other _allocator_node_sentinel; // Peu clair, verifier syntaxe // SENTINELL
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
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 map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator!=(const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator<(const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator>(const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator<=(const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator>=(const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
void swap(map<Key,T,Compare,Alloc>& lhs, map<Key,T,Compare,Alloc>& rhs);
/************************
* 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 "bst.tpp"
# include "map.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
// banlanced binary search tree :
// https://www.youtube.com/watch?v=vRwi_UcZGjU
// entinel node :
// https://en.wikipedia.org/wiki/Sentinel_node
#endif