629 lines
11 KiB
C++
629 lines
11 KiB
C++
|
|
#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
|
|
|