Implement Set, Refactor Map into Tree
This commit is contained in:
Dynamitos
@@ -3,7 +3,9 @@ target_sources(Engine
|
||||
Array.h
|
||||
List.h
|
||||
Map.h
|
||||
Pair.h)
|
||||
Pair.h
|
||||
Set.h
|
||||
Tree.h)
|
||||
|
||||
target_sources(Engine
|
||||
PUBLIC FILE_SET HEADERS
|
||||
@@ -11,4 +13,6 @@ target_sources(Engine
|
||||
Array.h
|
||||
List.h
|
||||
Map.h
|
||||
Pair.h)
|
||||
Pair.h
|
||||
Set.h
|
||||
Tree.h)
|
||||
+44
-543
@@ -2,416 +2,101 @@
|
||||
#include <utility>
|
||||
#include "Array.h"
|
||||
#include "Pair.h"
|
||||
#include "Tree.h"
|
||||
#include "Serialization/Serialization.h"
|
||||
|
||||
namespace Seele
|
||||
{
|
||||
template<typename KeyType, typename PairType>
|
||||
struct _KeyFun
|
||||
{
|
||||
const KeyType& operator()(const PairType& pair) const
|
||||
{
|
||||
return pair.key;
|
||||
}
|
||||
};
|
||||
template <typename K,
|
||||
typename V,
|
||||
typename Compare = std::less<K>,
|
||||
typename Allocator = std::pmr::polymorphic_allocator<Pair<const K,V>>>
|
||||
struct Map
|
||||
typename Allocator = std::pmr::polymorphic_allocator<Pair<const K, V>>>
|
||||
struct Map : public Tree<K, Pair<K, V>, _KeyFun<K, Pair<K, V>>, Compare, Allocator>
|
||||
{
|
||||
private:
|
||||
struct Node
|
||||
{
|
||||
Node* leftChild;
|
||||
Node* rightChild;
|
||||
Pair<K, V> pair;
|
||||
Node()
|
||||
: leftChild(nullptr)
|
||||
, rightChild(nullptr)
|
||||
, pair()
|
||||
{
|
||||
}
|
||||
Node(const Node& other) = default;
|
||||
Node(Node&& other) = default;
|
||||
Node& operator=(const Node& other) = default;
|
||||
Node& operator=(Node&& other) = default;
|
||||
Node(K key)
|
||||
: leftChild(nullptr)
|
||||
, rightChild(nullptr)
|
||||
, pair(std::move(key))
|
||||
{
|
||||
}
|
||||
~Node()
|
||||
{
|
||||
}
|
||||
};
|
||||
using NodeAlloc = std::allocator_traits<Allocator>::template rebind_alloc<Node>;
|
||||
public:
|
||||
template<typename PairType>
|
||||
class IteratorBase
|
||||
{
|
||||
public:
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
using value_type = PairType;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using reference = PairType&;
|
||||
using pointer = PairType*;
|
||||
|
||||
constexpr IteratorBase(Node* x = nullptr, Array<Node*> &&beginIt = Array<Node*>())
|
||||
: node(x), traversal(std::move(beginIt))
|
||||
{
|
||||
}
|
||||
constexpr IteratorBase(const IteratorBase &i)
|
||||
: node(i.node), traversal(i.traversal)
|
||||
{
|
||||
}
|
||||
constexpr IteratorBase(IteratorBase&& i)
|
||||
: node(std::move(i.node)), traversal(std::move(i.traversal))
|
||||
{
|
||||
}
|
||||
constexpr IteratorBase& operator=(const IteratorBase& other)
|
||||
{
|
||||
if(this != &other)
|
||||
{
|
||||
node = other.node;
|
||||
traversal = other.traversal;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr IteratorBase& operator=(IteratorBase&& other)
|
||||
{
|
||||
if(this != &other)
|
||||
{
|
||||
node = std::move(other.node);
|
||||
traversal = std::move(other.traversal);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr reference operator*() const
|
||||
{
|
||||
return node->pair;
|
||||
}
|
||||
constexpr pointer operator->() const
|
||||
{
|
||||
return &(node->pair);
|
||||
}
|
||||
constexpr bool operator!=(const IteratorBase &other)
|
||||
{
|
||||
return node != other.node;
|
||||
}
|
||||
constexpr bool operator==(const IteratorBase &other)
|
||||
{
|
||||
return node == other.node;
|
||||
}
|
||||
constexpr IteratorBase &operator++()
|
||||
{
|
||||
node = node->rightChild;
|
||||
while (node != nullptr
|
||||
&& node->leftChild != nullptr)
|
||||
{
|
||||
traversal.add(node);
|
||||
node = node->leftChild;
|
||||
}
|
||||
if (node == nullptr
|
||||
&& traversal.size() > 0)
|
||||
{
|
||||
node = traversal.back();
|
||||
traversal.pop();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr IteratorBase &operator--()
|
||||
{
|
||||
node = node->leftChild;
|
||||
while (node != nullptr
|
||||
&& node->rightChild != nullptr)
|
||||
{
|
||||
traversal.add(node);
|
||||
node = node->rightchild;
|
||||
}
|
||||
if (node == nullptr
|
||||
&& traversal.size() > 0)
|
||||
{
|
||||
node = traversal.back();
|
||||
traversal.pop();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr IteratorBase operator--(int)
|
||||
{
|
||||
IteratorBase tmp(*this);
|
||||
--*this;
|
||||
return tmp;
|
||||
}
|
||||
constexpr IteratorBase operator++(int)
|
||||
{
|
||||
IteratorBase tmp(*this);
|
||||
++*this;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private:
|
||||
Node* node;
|
||||
Array<Node*> traversal;
|
||||
};
|
||||
using Iterator = IteratorBase<Pair<K,V>>;
|
||||
using ConstIterator = IteratorBase<const Pair<K,V>>;
|
||||
|
||||
using key_type = K;
|
||||
using Super = Tree<K, Pair<K, V>, _KeyFun<K, Pair<K, V>>, Compare, Allocator>;
|
||||
using key_type = Super::key_type;
|
||||
using mapped_type = V;
|
||||
using value_type = Pair<K,V>;
|
||||
using allocator_type = Allocator;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using reference = value_type&;
|
||||
using const_reference = const value_type&;
|
||||
using pointer = std::allocator_traits<Allocator>::pointer;
|
||||
using const_pointer = std::allocator_traits<Allocator>::const_pointer;
|
||||
using value_type = Super::value_type;
|
||||
|
||||
using allocator_type = Super::allocator_type;
|
||||
using size_type = Super::size_type;
|
||||
using difference_type = Super::difference_type;
|
||||
using reference = Super::reference;
|
||||
using const_reference = Super::reference;
|
||||
using pointer = Super::pointer;
|
||||
using const_pointer = Super::const_pointer;
|
||||
|
||||
using iterator = Super::iterator;
|
||||
using const_iterator = Super::const_iterator;
|
||||
using reverse_iterator = Super::reverse_iterator;
|
||||
using const_reverse_iterator = Super::const_reverse_iterator;
|
||||
|
||||
using iterator = Iterator;
|
||||
using const_iterator = ConstIterator;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
constexpr Map() noexcept
|
||||
: root(nullptr)
|
||||
, beginIt(nullptr)
|
||||
, endIt(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(Compare())
|
||||
: Super()
|
||||
{
|
||||
}
|
||||
constexpr explicit Map(const Compare& comp, const Allocator& alloc = Allocator()) noexcept(noexcept(Allocator()))
|
||||
: alloc(alloc)
|
||||
, root(nullptr)
|
||||
, beginIt(nullptr)
|
||||
, endIt(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(comp)
|
||||
: Super(comp, alloc)
|
||||
{
|
||||
}
|
||||
constexpr explicit Map(const Allocator& alloc) noexcept(noexcept(Compare()))
|
||||
: alloc(alloc)
|
||||
, root(nullptr)
|
||||
, beginIt(nullptr)
|
||||
, endIt(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(Compare())
|
||||
: Super(alloc)
|
||||
{
|
||||
}
|
||||
constexpr Map(const Map& other)
|
||||
: alloc(other.alloc)
|
||||
, root(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(other.comp)
|
||||
{
|
||||
for(const auto& [key, val] : other)
|
||||
{
|
||||
this->operator[](key) = val;
|
||||
}
|
||||
}
|
||||
constexpr Map(Map&& other) noexcept
|
||||
: alloc(std::move(other.alloc))
|
||||
, root(std::move(other.root))
|
||||
, iteratorsDirty(true)
|
||||
, _size(std::move(other._size))
|
||||
, comp(std::move(other.comp))
|
||||
{
|
||||
}
|
||||
constexpr ~Map() noexcept
|
||||
{
|
||||
clear();
|
||||
}
|
||||
constexpr Map& operator=(const Map& other)
|
||||
{
|
||||
if(this != &other)
|
||||
{
|
||||
alloc = other.alloc;
|
||||
comp = other.comp;
|
||||
root = nullptr;
|
||||
_size = 0;
|
||||
for(const auto& [key, val] : other)
|
||||
{
|
||||
this->operator[](key) = val;
|
||||
}
|
||||
markIteratorsDirty();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr Map& operator=(Map&& other)
|
||||
{
|
||||
if(this != &other)
|
||||
{
|
||||
alloc = std::move(other.alloc);
|
||||
root = std::move(other.root);
|
||||
_size = std::move(other._size);
|
||||
comp = std::move(other.comp);
|
||||
markIteratorsDirty();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr mapped_type& operator[](const key_type& key)
|
||||
{
|
||||
root = splay(root, key);
|
||||
if (root == nullptr || !equal(root->pair.key, key))
|
||||
{
|
||||
root = insert(root, key);
|
||||
_size++;
|
||||
}
|
||||
markIteratorsDirty();
|
||||
return root->pair.value;
|
||||
auto [it, inserted] = Super::insert(Pair<K, V>(key, V()));
|
||||
return it->value;
|
||||
}
|
||||
constexpr const mapped_type& operator[](const key_type& key) const
|
||||
{
|
||||
Node* it = root;
|
||||
while (!equal(it->pair.key, key))
|
||||
{
|
||||
if (comp(key, it->pair.key))
|
||||
{
|
||||
it = it->leftChild;
|
||||
}
|
||||
else
|
||||
{
|
||||
it = it->rightChild;
|
||||
}
|
||||
}
|
||||
return it->pair.value;
|
||||
return Super::find(key)->value;
|
||||
}
|
||||
constexpr mapped_type& at(const key_type& key)
|
||||
{
|
||||
root = splay(root, key);
|
||||
if (root == nullptr || !equal(root->pair.key, key))
|
||||
iterator elem = Super::find(key);
|
||||
if (elem == Super::end())
|
||||
{
|
||||
throw std::logic_error("Key not found");
|
||||
}
|
||||
markIteratorsDirty();
|
||||
return root->pair.value;
|
||||
return elem->value;
|
||||
}
|
||||
constexpr mapped_type& at(key_type&& key)
|
||||
{
|
||||
root = splay(root, std::move(key));
|
||||
if (root == nullptr || !equal(root->pair.key, key))
|
||||
{
|
||||
throw std::logic_error("Key not found");
|
||||
}
|
||||
markIteratorsDirty();
|
||||
return root->pair.value;
|
||||
}
|
||||
|
||||
constexpr const mapped_type& at(const key_type& key) const
|
||||
{
|
||||
Node* it = root;
|
||||
while (!equal(it->pair.key, key))
|
||||
{
|
||||
if (comp(key, it->pair.key))
|
||||
{
|
||||
it = it->leftChild;
|
||||
}
|
||||
else
|
||||
{
|
||||
it = it->rightChild;
|
||||
}
|
||||
}
|
||||
return it->pair.value;
|
||||
return Super::find(key)->value;
|
||||
}
|
||||
constexpr iterator find(const key_type& key)
|
||||
{
|
||||
root = splay(root, key);
|
||||
refreshIterators();
|
||||
if (root == nullptr || !equal(root->pair.key, key))
|
||||
{
|
||||
return endIt;
|
||||
}
|
||||
return iterator(root);
|
||||
}
|
||||
constexpr iterator find(key_type&& key)
|
||||
{
|
||||
root = splay(root, std::move(key));
|
||||
refreshIterators();
|
||||
if (root == nullptr || !equal(root->pair.key, key))
|
||||
{
|
||||
return endIt;
|
||||
}
|
||||
return iterator(root);
|
||||
return Super::find(key);
|
||||
}
|
||||
constexpr iterator erase(const key_type& key)
|
||||
{
|
||||
root = remove(root, key);
|
||||
refreshIterators();
|
||||
assert(root != nullptr || _size == 0);
|
||||
return iterator(root);
|
||||
}
|
||||
constexpr iterator erase(key_type&& key)
|
||||
{
|
||||
root = remove(root, std::move(key));
|
||||
refreshIterators();
|
||||
return iterator(root);
|
||||
}
|
||||
constexpr void clear()
|
||||
{
|
||||
while(_size > 0)
|
||||
{
|
||||
root = remove(root, root->pair.key);
|
||||
}
|
||||
root = nullptr;
|
||||
markIteratorsDirty();
|
||||
return Super::remove(key);
|
||||
}
|
||||
constexpr bool exists(const key_type& key)
|
||||
{
|
||||
return find(key) != endIt;
|
||||
}
|
||||
constexpr bool exists(key_type&& key)
|
||||
{
|
||||
return find(std::move(key)) != endIt;
|
||||
return Super::find(key) != Super::end();
|
||||
}
|
||||
constexpr bool contains(const key_type& key)
|
||||
{
|
||||
return exists(key);
|
||||
}
|
||||
constexpr bool contains(key_type&& key)
|
||||
constexpr Pair<iterator, bool> insert(const value_type& val)
|
||||
{
|
||||
return exists(key);
|
||||
}
|
||||
constexpr iterator begin()
|
||||
{
|
||||
if(iteratorsDirty)
|
||||
{
|
||||
refreshIterators();
|
||||
}
|
||||
return beginIt;
|
||||
}
|
||||
constexpr iterator end()
|
||||
{
|
||||
if(iteratorsDirty)
|
||||
{
|
||||
refreshIterators();
|
||||
}
|
||||
return endIt;
|
||||
}
|
||||
constexpr iterator begin() const
|
||||
{
|
||||
if(iteratorsDirty)
|
||||
{
|
||||
return calcBeginIterator();
|
||||
}
|
||||
return beginIt;
|
||||
}
|
||||
constexpr iterator end() const
|
||||
{
|
||||
if(iteratorsDirty)
|
||||
{
|
||||
return calcEndIterator();
|
||||
}
|
||||
return endIt;
|
||||
}
|
||||
constexpr bool empty() const
|
||||
{
|
||||
return _size == 0;
|
||||
}
|
||||
constexpr size_type size() const
|
||||
{
|
||||
return _size;
|
||||
return Super::insert(val);
|
||||
}
|
||||
void save(ArchiveBuffer& buffer) const
|
||||
{
|
||||
buffer.writeBytes(&_size, sizeof(uint64));
|
||||
size_t s = Super::size();
|
||||
buffer.writeBytes(&s, sizeof(uint64));
|
||||
for(const auto& [k, v] : *this)
|
||||
{
|
||||
Serialization::save(buffer, k);
|
||||
@@ -431,189 +116,5 @@ public:
|
||||
this->operator[](std::move(k)) = std::move(v);
|
||||
}
|
||||
}
|
||||
private:
|
||||
void verifyTree()
|
||||
{
|
||||
size_t numElems = 0;
|
||||
for (const auto& it : *this)
|
||||
{
|
||||
numElems++;
|
||||
}
|
||||
assert(numElems == _size);
|
||||
}
|
||||
void markIteratorsDirty()
|
||||
{
|
||||
iteratorsDirty = true;
|
||||
}
|
||||
void refreshIterators()
|
||||
{
|
||||
beginIt = calcBeginIterator();
|
||||
endIt = calcEndIterator();
|
||||
iteratorsDirty = false;
|
||||
}
|
||||
constexpr Iterator calcBeginIterator() const
|
||||
{
|
||||
Node* begin = root;
|
||||
Array<Node*> beginTraversal;
|
||||
while (begin != nullptr)
|
||||
{
|
||||
beginTraversal.add(begin);
|
||||
begin = begin->leftChild;
|
||||
}
|
||||
if(!beginTraversal.empty())
|
||||
{
|
||||
begin = beginTraversal.back();
|
||||
beginTraversal.pop();
|
||||
}
|
||||
return Iterator(begin, std::move(beginTraversal));
|
||||
}
|
||||
constexpr Iterator calcEndIterator() const
|
||||
{
|
||||
Node* endIndex = root;
|
||||
Array<Node*> endTraversal;
|
||||
while (endIndex != nullptr)
|
||||
{
|
||||
endTraversal.add(endIndex);
|
||||
endIndex = endIndex->rightChild;
|
||||
}
|
||||
return Iterator(endIndex, std::move(endTraversal));
|
||||
}
|
||||
NodeAlloc alloc;
|
||||
Node* root;
|
||||
Iterator beginIt;
|
||||
Iterator endIt;
|
||||
bool iteratorsDirty;
|
||||
size_type _size;
|
||||
Compare comp;
|
||||
Node* rotateLeft(Node* x)
|
||||
{
|
||||
Node* y = x->rightChild;
|
||||
x->rightChild = y->leftChild;
|
||||
y->leftChild = x;
|
||||
return y;
|
||||
}
|
||||
Node* rotateRight(Node* x)
|
||||
{
|
||||
Node* y = x->leftChild;
|
||||
x->leftChild = y->rightChild;
|
||||
y->rightChild = x;
|
||||
return y;
|
||||
}
|
||||
template<class KeyType>
|
||||
Node* insert(Node* r, KeyType&& key)
|
||||
{
|
||||
if (r == nullptr)
|
||||
{
|
||||
root = alloc.allocate(1);
|
||||
std::allocator_traits<NodeAlloc>::construct(alloc, root, std::forward<KeyType>(key));
|
||||
return root;
|
||||
}
|
||||
r = splay(r, key);
|
||||
|
||||
if (equal(r->pair.key, key))
|
||||
return r;
|
||||
|
||||
Node *newNode = alloc.allocate(1);
|
||||
std::allocator_traits<NodeAlloc>::construct(alloc, newNode, std::forward<KeyType>(key));
|
||||
|
||||
if (comp(newNode->pair.key, r->pair.key))
|
||||
{
|
||||
newNode->rightChild = r;
|
||||
newNode->leftChild = r->leftChild;
|
||||
r->leftChild = nullptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
newNode->leftChild = r;
|
||||
newNode->rightChild = r->rightChild;
|
||||
r->rightChild = nullptr;
|
||||
}
|
||||
return newNode;
|
||||
}
|
||||
template<class KeyType>
|
||||
Node* remove(Node* r, KeyType&& key)
|
||||
{
|
||||
Node* temp;
|
||||
if (r == nullptr)
|
||||
return nullptr;
|
||||
|
||||
r = splay(r, key);
|
||||
|
||||
if (!equal(r->pair.key, key))
|
||||
return r;
|
||||
|
||||
if (r->leftChild == nullptr)
|
||||
{
|
||||
temp = r;
|
||||
r = r->rightChild;
|
||||
}
|
||||
else
|
||||
{
|
||||
temp = r;
|
||||
|
||||
r = splay(r->leftChild, key);
|
||||
r->rightChild = temp->rightChild;
|
||||
}
|
||||
std::allocator_traits<NodeAlloc>::destroy(alloc, temp);
|
||||
alloc.deallocate(temp, 1);
|
||||
_size--;
|
||||
return r;
|
||||
}
|
||||
template<class KeyType>
|
||||
Node* splay(Node* r, KeyType&& key)
|
||||
{
|
||||
if (r == nullptr || equal(r->pair.key, key))
|
||||
{
|
||||
return r;
|
||||
}
|
||||
if (comp(key, r->pair.key))
|
||||
{
|
||||
if (r->leftChild == nullptr)
|
||||
return r;
|
||||
|
||||
if (comp(key, r->leftChild->pair.key))
|
||||
{
|
||||
r->leftChild->leftChild = splay(r->leftChild->leftChild, key);
|
||||
|
||||
r = rotateRight(r);
|
||||
}
|
||||
else if (comp(r->leftChild->pair.key, key))
|
||||
{
|
||||
r->leftChild->rightChild = splay(r->leftChild->rightChild, key);
|
||||
|
||||
if (r->leftChild->rightChild != nullptr)
|
||||
{
|
||||
r->leftChild = rotateLeft(r->leftChild);
|
||||
}
|
||||
}
|
||||
return (r->leftChild == nullptr) ? r : rotateRight(r);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (r->rightChild == nullptr)
|
||||
return r;
|
||||
|
||||
if (comp(key, r->rightChild->pair.key))
|
||||
{
|
||||
r->rightChild->leftChild = splay(r->rightChild->leftChild, key);
|
||||
|
||||
if (r->rightChild->leftChild != nullptr)
|
||||
{
|
||||
r->rightChild = rotateRight(r->rightChild);
|
||||
}
|
||||
}
|
||||
else if (comp(r->rightChild->pair.key, key))
|
||||
{
|
||||
r->rightChild->rightChild = splay(r->rightChild->rightChild, key);
|
||||
|
||||
r = rotateLeft(r);
|
||||
}
|
||||
return (r->rightChild == nullptr) ? r : rotateLeft(r);
|
||||
}
|
||||
}
|
||||
bool equal(const key_type& a, const key_type& b) const
|
||||
{
|
||||
return !comp(a, b) && !comp(b, a);
|
||||
}
|
||||
};
|
||||
} // namespace Seele
|
||||
|
||||
@@ -6,20 +6,21 @@ template <typename K, typename V>
|
||||
struct Pair
|
||||
{
|
||||
public:
|
||||
Pair()
|
||||
constexpr Pair()
|
||||
: key(K()), value(V())
|
||||
{}
|
||||
constexpr Pair(const K & key, const V & value)
|
||||
: key(key), value(value)
|
||||
{}
|
||||
template<class U1 = K, class U2 = V>
|
||||
constexpr Pair(U1&& x, U2&& y)
|
||||
: key(std::forward<U1>(x))
|
||||
, value(std::forward<U2>(y))
|
||||
{
|
||||
}
|
||||
Pair(const Pair& other) = default;
|
||||
Pair(Pair&& other) = default;
|
||||
~Pair(){}
|
||||
template<class KeyType>
|
||||
explicit Pair(KeyType&& key)
|
||||
: key(std::forward<KeyType>(key)), value(V())
|
||||
{}
|
||||
template<class KeyType, class ValueType>
|
||||
explicit Pair(KeyType&& key, ValueType&& value)
|
||||
: key(std::forward<KeyType>(key)), value(std::forward<ValueType>(value))
|
||||
{}
|
||||
Pair& operator=(const Pair& other) = default;
|
||||
Pair& operator=(Pair&& other) = default;
|
||||
constexpr friend bool operator<(const Pair& left, const Pair& right)
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
#pragma once
|
||||
#include <utility>
|
||||
#include "Array.h"
|
||||
#include "Tree.h"
|
||||
|
||||
namespace Seele
|
||||
{
|
||||
template<class Key, class Compare = std::less<Key>, class Allocator = std::pmr::polymorphic_allocator<Key>>
|
||||
class Set : public Tree<Key, Key, std::identity, Compare, Allocator>
|
||||
{
|
||||
public:
|
||||
using Super = Tree<Key, Key, std::identity, Compare, Allocator>;
|
||||
using key_type = Key;
|
||||
using value_type = Key;
|
||||
using node_type = Super::Node;
|
||||
using allocator_type = Super::allocator_type;
|
||||
using size_type = Super::size_type;
|
||||
using difference_type = Super::difference_type;
|
||||
using reference = value_type&;
|
||||
using const_reference = const value_type&;
|
||||
using pointer = std::allocator_traits<Allocator>::pointer;
|
||||
using const_pointer = std::allocator_traits<Allocator>::const_pointer;
|
||||
|
||||
using iterator = Super::iterator;
|
||||
using const_iterator = Super::const_iterator;
|
||||
using reverse_iterator = Super::reverse_iterator;
|
||||
using const_reverse_iterator = Super::const_reverse_iterator;
|
||||
|
||||
Set()
|
||||
: Set(Compare())
|
||||
{
|
||||
}
|
||||
explicit Set(const Compare& comp, const Allocator alloc = Allocator())
|
||||
: Super(comp, alloc)
|
||||
{
|
||||
}
|
||||
explicit Set(const Allocator alloc)
|
||||
: Super(alloc)
|
||||
{
|
||||
}
|
||||
constexpr Pair<iterator, bool> insert(const value_type& value)
|
||||
{
|
||||
return Super::insert(value);
|
||||
}
|
||||
};
|
||||
} // namespace Seele
|
||||
@@ -0,0 +1,510 @@
|
||||
#pragma once
|
||||
#include <memory_resource>
|
||||
#include "Pair.h"
|
||||
|
||||
namespace Seele
|
||||
{
|
||||
template <
|
||||
typename KeyType,
|
||||
typename NodeData,
|
||||
typename KeyFun,
|
||||
typename Compare,
|
||||
typename Allocator>
|
||||
struct Tree
|
||||
{
|
||||
protected:
|
||||
struct Node
|
||||
{
|
||||
Node* leftChild;
|
||||
Node* rightChild;
|
||||
NodeData data;
|
||||
};
|
||||
using NodeAlloc = std::allocator_traits<Allocator>::template rebind_alloc<Node>;
|
||||
public:
|
||||
template<typename IterType>
|
||||
class IteratorBase
|
||||
{
|
||||
public:
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
using value_type = IterType;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using reference = IterType&;
|
||||
using pointer = IterType*;
|
||||
|
||||
constexpr IteratorBase(Node* x = nullptr, Array<Node*>&& beginIt = Array<Node*>())
|
||||
: node(x), traversal(std::move(beginIt))
|
||||
{
|
||||
}
|
||||
constexpr IteratorBase(const IteratorBase& i)
|
||||
: node(i.node), traversal(i.traversal)
|
||||
{
|
||||
}
|
||||
constexpr IteratorBase(IteratorBase&& i)
|
||||
: node(std::move(i.node)), traversal(std::move(i.traversal))
|
||||
{
|
||||
}
|
||||
constexpr IteratorBase& operator=(const IteratorBase& other)
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
node = other.node;
|
||||
traversal = other.traversal;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr IteratorBase& operator=(IteratorBase&& other)
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
node = std::move(other.node);
|
||||
traversal = std::move(other.traversal);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr reference operator*() const
|
||||
{
|
||||
return node->data;
|
||||
}
|
||||
constexpr pointer operator->() const
|
||||
{
|
||||
return &(node->data);
|
||||
}
|
||||
constexpr bool operator!=(const IteratorBase& other)
|
||||
{
|
||||
return node != other.node;
|
||||
}
|
||||
constexpr bool operator==(const IteratorBase& other)
|
||||
{
|
||||
return node == other.node;
|
||||
}
|
||||
constexpr IteratorBase& operator++()
|
||||
{
|
||||
node = node->rightChild;
|
||||
while (node != nullptr
|
||||
&& node->leftChild != nullptr)
|
||||
{
|
||||
traversal.add(node);
|
||||
node = node->leftChild;
|
||||
}
|
||||
if (node == nullptr
|
||||
&& traversal.size() > 0)
|
||||
{
|
||||
node = traversal.back();
|
||||
traversal.pop();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr IteratorBase& operator--()
|
||||
{
|
||||
node = node->leftChild;
|
||||
while (node != nullptr
|
||||
&& node->rightChild != nullptr)
|
||||
{
|
||||
traversal.add(node);
|
||||
node = node->rightchild;
|
||||
}
|
||||
if (node == nullptr
|
||||
&& traversal.size() > 0)
|
||||
{
|
||||
node = traversal.back();
|
||||
traversal.pop();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr IteratorBase operator--(int)
|
||||
{
|
||||
IteratorBase tmp(*this);
|
||||
--*this;
|
||||
return tmp;
|
||||
}
|
||||
constexpr IteratorBase operator++(int)
|
||||
{
|
||||
IteratorBase tmp(*this);
|
||||
++*this;
|
||||
return tmp;
|
||||
}
|
||||
Node* getNode()
|
||||
{
|
||||
return node;
|
||||
}
|
||||
private:
|
||||
Node* node;
|
||||
Array<Node*> traversal;
|
||||
};
|
||||
using Iterator = IteratorBase<NodeData>;
|
||||
using ConstIterator = IteratorBase<const NodeData>;
|
||||
|
||||
using key_type = KeyType;
|
||||
using value_type = NodeData;
|
||||
using allocator_type = Allocator;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using reference = value_type&;
|
||||
using const_reference = const value_type&;
|
||||
using pointer = std::allocator_traits<Allocator>::pointer;
|
||||
using const_pointer = std::allocator_traits<Allocator>::const_pointer;
|
||||
|
||||
using iterator = Iterator;
|
||||
using const_iterator = ConstIterator;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
||||
|
||||
constexpr Tree() noexcept
|
||||
: root(nullptr)
|
||||
, beginIt(nullptr)
|
||||
, endIt(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(Compare())
|
||||
{
|
||||
}
|
||||
constexpr explicit Tree(const Compare& comp, const Allocator& alloc = Allocator()) noexcept(noexcept(Allocator()))
|
||||
: alloc(alloc)
|
||||
, root(nullptr)
|
||||
, beginIt(nullptr)
|
||||
, endIt(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(comp)
|
||||
{
|
||||
}
|
||||
constexpr explicit Tree(const Allocator& alloc) noexcept(noexcept(Compare()))
|
||||
: alloc(alloc)
|
||||
, root(nullptr)
|
||||
, beginIt(nullptr)
|
||||
, endIt(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size(0)
|
||||
, comp(Compare())
|
||||
{
|
||||
}
|
||||
constexpr Tree(const Tree& other)
|
||||
: alloc(other.alloc)
|
||||
, root(nullptr)
|
||||
, iteratorsDirty(true)
|
||||
, _size()
|
||||
, comp(other.comp)
|
||||
{
|
||||
std::copy(other.begin(), other.end(), begin());
|
||||
}
|
||||
constexpr Tree(Tree&& other) noexcept
|
||||
: alloc(std::move(other.alloc))
|
||||
, root(std::move(other.root))
|
||||
, iteratorsDirty(true)
|
||||
, _size(std::move(other._size))
|
||||
, comp(std::move(other.comp))
|
||||
{
|
||||
}
|
||||
constexpr ~Tree() noexcept
|
||||
{
|
||||
clear();
|
||||
}
|
||||
constexpr Tree& operator=(const Tree& other)
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
clear();
|
||||
alloc = other.alloc;
|
||||
comp = other.comp;
|
||||
root = nullptr;
|
||||
_size = 0;
|
||||
std::copy(other.begin(), other.end(), begin());
|
||||
markIteratorsDirty();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr Tree& operator=(Tree&& other)
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
clear();
|
||||
alloc = std::move(other.alloc);
|
||||
root = std::move(other.root);
|
||||
_size = std::move(other._size);
|
||||
comp = std::move(other.comp);
|
||||
markIteratorsDirty();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
constexpr void clear()
|
||||
{
|
||||
while (_size > 0)
|
||||
{
|
||||
root = _remove(root, keyFun(root->data));
|
||||
}
|
||||
root = nullptr;
|
||||
markIteratorsDirty();
|
||||
}
|
||||
constexpr iterator begin()
|
||||
{
|
||||
if (iteratorsDirty)
|
||||
{
|
||||
refreshIterators();
|
||||
}
|
||||
return beginIt;
|
||||
}
|
||||
constexpr iterator end()
|
||||
{
|
||||
if (iteratorsDirty)
|
||||
{
|
||||
refreshIterators();
|
||||
}
|
||||
return endIt;
|
||||
}
|
||||
constexpr iterator begin() const
|
||||
{
|
||||
if (iteratorsDirty)
|
||||
{
|
||||
return calcBeginIterator();
|
||||
}
|
||||
return beginIt;
|
||||
}
|
||||
constexpr iterator end() const
|
||||
{
|
||||
if (iteratorsDirty)
|
||||
{
|
||||
return calcEndIterator();
|
||||
}
|
||||
return endIt;
|
||||
}
|
||||
constexpr bool empty() const
|
||||
{
|
||||
return _size == 0;
|
||||
}
|
||||
constexpr size_type size() const
|
||||
{
|
||||
return _size;
|
||||
}
|
||||
protected:
|
||||
constexpr iterator find(const key_type& key)
|
||||
{
|
||||
root = _splay(root, key);
|
||||
if (root == nullptr || !equal(root->data, key))
|
||||
{
|
||||
return end();
|
||||
}
|
||||
return iterator(root);
|
||||
}
|
||||
constexpr iterator find(const key_type& key) const
|
||||
{
|
||||
Node* it = root;
|
||||
while (!equal(it->data, key))
|
||||
{
|
||||
if (comp(key, keyFun(it->data)))
|
||||
{
|
||||
it = it->leftChild;
|
||||
}
|
||||
else
|
||||
{
|
||||
it = it->rightChild;
|
||||
}
|
||||
}
|
||||
return iterator(it);
|
||||
}
|
||||
constexpr Pair<iterator, bool> insert(const NodeData& data)
|
||||
{
|
||||
auto [r, inserted] = _insert(root, data);
|
||||
root = r;
|
||||
return Pair<iterator, bool>(iterator(root), inserted);
|
||||
}
|
||||
constexpr Pair<iterator, bool> insert(NodeData&& data)
|
||||
{
|
||||
auto [r, inserted] = _insert(root, std::move(data));
|
||||
root = r;
|
||||
return Pair<iterator, bool>(iterator(root), inserted);
|
||||
}
|
||||
constexpr iterator remove(const key_type& key)
|
||||
{
|
||||
root = _remove(root, key);
|
||||
return iterator(root);
|
||||
}
|
||||
private:
|
||||
void verifyTree()
|
||||
{
|
||||
size_t numElems = 0;
|
||||
for (const auto& it : *this)
|
||||
{
|
||||
numElems++;
|
||||
}
|
||||
assert(numElems == _size);
|
||||
}
|
||||
void markIteratorsDirty()
|
||||
{
|
||||
iteratorsDirty = true;
|
||||
}
|
||||
void refreshIterators()
|
||||
{
|
||||
beginIt = calcBeginIterator();
|
||||
endIt = calcEndIterator();
|
||||
iteratorsDirty = false;
|
||||
}
|
||||
constexpr Iterator calcBeginIterator() const
|
||||
{
|
||||
Node* begin = root;
|
||||
Array<Node*> beginTraversal;
|
||||
while (begin != nullptr)
|
||||
{
|
||||
beginTraversal.add(begin);
|
||||
begin = begin->leftChild;
|
||||
}
|
||||
if (!beginTraversal.empty())
|
||||
{
|
||||
begin = beginTraversal.back();
|
||||
beginTraversal.pop();
|
||||
}
|
||||
return Iterator(begin, std::move(beginTraversal));
|
||||
}
|
||||
constexpr Iterator calcEndIterator() const
|
||||
{
|
||||
Node* endIndex = root;
|
||||
Array<Node*> endTraversal;
|
||||
while (endIndex != nullptr)
|
||||
{
|
||||
endTraversal.add(endIndex);
|
||||
endIndex = endIndex->rightChild;
|
||||
}
|
||||
return Iterator(endIndex, std::move(endTraversal));
|
||||
}
|
||||
NodeAlloc alloc;
|
||||
Node* root;
|
||||
Iterator beginIt;
|
||||
Iterator endIt;
|
||||
bool iteratorsDirty;
|
||||
size_type _size;
|
||||
Compare comp;
|
||||
KeyFun keyFun = KeyFun();
|
||||
Node* rotateLeft(Node* x)
|
||||
{
|
||||
Node* y = x->rightChild;
|
||||
x->rightChild = y->leftChild;
|
||||
y->leftChild = x;
|
||||
return y;
|
||||
}
|
||||
Node* rotateRight(Node* x)
|
||||
{
|
||||
Node* y = x->leftChild;
|
||||
x->leftChild = y->rightChild;
|
||||
y->rightChild = x;
|
||||
return y;
|
||||
}
|
||||
template<class NodeDataType>
|
||||
Pair<Node*, bool> _insert(Node* r, NodeDataType&& data)
|
||||
{
|
||||
if (r == nullptr)
|
||||
{
|
||||
root = alloc.allocate(1);
|
||||
std::allocator_traits<NodeAlloc>::construct(alloc, root, nullptr, nullptr, std::forward<NodeDataType>(data));
|
||||
_size++;
|
||||
return Pair<Node*, bool>(root, true);
|
||||
}
|
||||
r = _splay(r, keyFun(data));
|
||||
|
||||
if (equal(r->data, keyFun(data)))
|
||||
return Pair<Node*, bool>(r, false);
|
||||
|
||||
Node* newNode = alloc.allocate(1);
|
||||
std::allocator_traits<NodeAlloc>::construct(alloc, newNode, nullptr, nullptr, std::forward<NodeDataType>(data));
|
||||
|
||||
if (comp(keyFun(r->data), keyFun(newNode->data)))
|
||||
{
|
||||
newNode->rightChild = r;
|
||||
newNode->leftChild = r->leftChild;
|
||||
r->leftChild = nullptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
newNode->leftChild = r;
|
||||
newNode->rightChild = r->rightChild;
|
||||
r->rightChild = nullptr;
|
||||
}
|
||||
_size++;
|
||||
return Pair<Node*, bool>(newNode, true);
|
||||
}
|
||||
template<class KeyType>
|
||||
Node* _remove(Node* r, KeyType&& key)
|
||||
{
|
||||
Node* temp;
|
||||
if (r == nullptr)
|
||||
return nullptr;
|
||||
|
||||
r = _splay(r, key);
|
||||
|
||||
if (!equal(r->data, key))
|
||||
return r;
|
||||
|
||||
if (r->leftChild == nullptr)
|
||||
{
|
||||
temp = r;
|
||||
r = r->rightChild;
|
||||
}
|
||||
else
|
||||
{
|
||||
temp = r;
|
||||
|
||||
r = _splay(r->leftChild, key);
|
||||
r->rightChild = temp->rightChild;
|
||||
}
|
||||
std::allocator_traits<NodeAlloc>::destroy(alloc, temp);
|
||||
alloc.deallocate(temp, 1);
|
||||
_size--;
|
||||
return r;
|
||||
}
|
||||
template<class KeyType>
|
||||
Node* _splay(Node* r, KeyType&& key)
|
||||
{
|
||||
if (r == nullptr || equal(r->data, key))
|
||||
{
|
||||
return r;
|
||||
}
|
||||
if (comp(keyFun(r->data), key))
|
||||
{
|
||||
if (r->leftChild == nullptr)
|
||||
return r;
|
||||
|
||||
if (comp(keyFun(r->leftChild->data), key))
|
||||
{
|
||||
r->leftChild->leftChild = _splay(r->leftChild->leftChild, key);
|
||||
|
||||
r = rotateRight(r);
|
||||
}
|
||||
else if (comp(keyFun(r->leftChild->data), key))
|
||||
{
|
||||
r->leftChild->rightChild = _splay(r->leftChild->rightChild, key);
|
||||
|
||||
if (r->leftChild->rightChild != nullptr)
|
||||
{
|
||||
r->leftChild = rotateLeft(r->leftChild);
|
||||
}
|
||||
}
|
||||
return (r->leftChild == nullptr) ? r : rotateRight(r);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (r->rightChild == nullptr)
|
||||
return r;
|
||||
|
||||
if (comp(keyFun(r->rightChild->data), key))
|
||||
{
|
||||
r->rightChild->leftChild = _splay(r->rightChild->leftChild, key);
|
||||
|
||||
if (r->rightChild->leftChild != nullptr)
|
||||
{
|
||||
r->rightChild = rotateRight(r->rightChild);
|
||||
}
|
||||
}
|
||||
else if (comp(keyFun(r->rightChild->data), key))
|
||||
{
|
||||
r->rightChild->rightChild = _splay(r->rightChild->rightChild, key);
|
||||
|
||||
r = rotateLeft(r);
|
||||
}
|
||||
return (r->rightChild == nullptr) ? r : rotateLeft(r);
|
||||
}
|
||||
}
|
||||
template<typename KeyType>
|
||||
bool equal(const NodeData& a, KeyType&& b) const
|
||||
{
|
||||
return !comp(keyFun(a), b) && !comp(b, keyFun(a));
|
||||
}
|
||||
};
|
||||
} // namespace Seele
|
||||
Reference in New Issue
Block a user