From f794190de0bcf24d2e6ecaaa5b861c98d47e9900 Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Sat, 13 Oct 2018 13:50:44 +0200 Subject: [PATCH] Add a DoublyLinkedList template and start using it for HashTable. --- AK/DoublyLinkedList.h | 142 ++++++++++++++++++++++++++++++++++++++++++ AK/HashTable.h | 20 +++--- 2 files changed, 152 insertions(+), 10 deletions(-) create mode 100644 AK/DoublyLinkedList.h diff --git a/AK/DoublyLinkedList.h b/AK/DoublyLinkedList.h new file mode 100644 index 00000000000..0ddf61dbe32 --- /dev/null +++ b/AK/DoublyLinkedList.h @@ -0,0 +1,142 @@ +#pragma once + +#include + +namespace AK { + +template +class DoublyLinkedList { +private: + struct Node { + explicit Node(T&& v) : value(v) { } + T value; + Node* next { nullptr }; + Node* prev { nullptr }; + }; + +public: + DoublyLinkedList() { } + ~DoublyLinkedList() { clear(); } + + bool isEmpty() const { return !head(); } + + void clear() + { + for (auto* node = m_head; node; ) { + auto* next = node->next; + delete node; + node = next; + } + m_head = nullptr; + m_tail = nullptr; + } + + T& first() { ASSERT(head()); return head()->value; } + const T& first() const { ASSERT(head()); return head()->value; } + T& last() { ASSERT(head()); return tail()->value; } + const T& last() const { ASSERT(head()); return tail()->value; } + + void append(T&& value) + { + auto* node = new Node(std::move(value)); + if (!m_head) { + m_head = node; + m_tail = node; + return; + } + m_tail->next = node; + node->prev = m_tail; + m_tail = node; + } + + bool containsSlow(const T& value) const + { + for (auto* node = m_head; node; node = node->next) { + if (node->value == value) + return true; + } + return false; + } + + class Iterator { + public: + bool operator!=(const Iterator& other) { return m_node != other.m_node; } + Iterator& operator++() { m_node = m_node->next; return *this; } + T& operator*() { return m_node->value; } + bool isEnd() const { return !m_node; } + static Iterator universalEnd() { return Iterator(nullptr); } + private: + friend class DoublyLinkedList; + explicit Iterator(DoublyLinkedList::Node* node) : m_node(node) { } + DoublyLinkedList::Node* m_node; + }; + + Iterator begin() { return Iterator(m_head); } + Iterator end() { return Iterator::universalEnd(); } + + class ConstIterator { + public: + bool operator!=(const ConstIterator& other) { return m_node != other.m_node; } + ConstIterator& operator++() { m_node = m_node->next; return *this; } + const T& operator*() const { return m_node->value; } + bool isEnd() const { return !m_node; } + static ConstIterator universalEnd() { return ConstIterator(nullptr); } + private: + friend class DoublyLinkedList; + explicit ConstIterator(const DoublyLinkedList::Node* node) : m_node(node) { } + const DoublyLinkedList::Node* m_node; + }; + + ConstIterator begin() const { return ConstIterator(m_head); } + ConstIterator end() const { return ConstIterator::universalEnd(); } + + ConstIterator find(const T& value) const + { + for (auto* node = m_head; node; node = node->next) { + if (node->value == value) + return ConstIterator(node); + } + return end(); + } + + Iterator find(const T& value) + { + for (auto* node = m_head; node; node = node->next) { + if (node->value == value) + return Iterator(node); + } + return end(); + } + + void remove(Iterator& it) + { + ASSERT(it.m_node); + auto* node = it.m_node; + if (node->prev) + node->prev->next = node->next; + if (node->next) + node->next->prev = node->prev; + if (m_head == node) + m_head = node->next; + if (m_tail == node) + m_tail = node->prev; + delete node; + } + +private: + friend class Iterator; + + Node* head() { return m_head; } + const Node* head() const { return m_head; } + + Node* tail() { return m_tail; } + const Node* tail() const { return m_tail; } + + Node* m_head { nullptr }; + Node* m_tail { nullptr }; +}; + +} + +using AK::DoublyLinkedList; + diff --git a/AK/HashTable.h b/AK/HashTable.h index 90c195e5201..59b89928098 100644 --- a/AK/HashTable.h +++ b/AK/HashTable.h @@ -1,7 +1,7 @@ #pragma once #include "Assertions.h" -#include "SinglyLinkedList.h" +#include "DoublyLinkedList.h" #include "Traits.h" #include #include @@ -16,7 +16,7 @@ template class HashTable { private: struct Bucket { - SinglyLinkedList chain; + DoublyLinkedList chain; }; public: @@ -104,12 +104,12 @@ public: } private: friend class HashTable; - explicit Iterator(HashTable& table, bool isEnd, typename SinglyLinkedList::Iterator bucketIterator = SinglyLinkedList::Iterator::universalEnd()) + explicit Iterator(HashTable& table, bool isEnd, typename DoublyLinkedList::Iterator bucketIterator = DoublyLinkedList::Iterator::universalEnd()) : m_table(table) , m_isEnd(isEnd) , m_bucketIterator(bucketIterator) { - if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != SinglyLinkedList::Iterator::universalEnd())) { + if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != DoublyLinkedList::Iterator::universalEnd())) { #ifdef HASHTABLE_DEBUG printf("bucket iterator init!\n"); #endif @@ -122,7 +122,7 @@ public: HashTable& m_table; unsigned m_bucketIndex { 0 }; bool m_isEnd { false }; - typename SinglyLinkedList::Iterator m_bucketIterator; + typename DoublyLinkedList::Iterator m_bucketIterator; }; Iterator begin() { return Iterator(*this, false); } @@ -168,7 +168,7 @@ public: m_isEnd = true; return; } - const SinglyLinkedList& chain = m_table.m_buckets[m_bucketIndex].chain; + const DoublyLinkedList& chain = m_table.m_buckets[m_bucketIndex].chain; m_bucketIterator = chain.begin(); } else { ++m_bucketIterator; @@ -179,16 +179,16 @@ public: } private: friend class HashTable; - ConstIterator(const HashTable& table, bool isEnd, typename SinglyLinkedList::ConstIterator bucketIterator = SinglyLinkedList::ConstIterator::universalEnd()) + ConstIterator(const HashTable& table, bool isEnd, typename DoublyLinkedList::ConstIterator bucketIterator = DoublyLinkedList::ConstIterator::universalEnd()) : m_table(table) , m_isEnd(isEnd) , m_bucketIterator(bucketIterator) { - if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != SinglyLinkedList::ConstIterator::universalEnd())) { + if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != DoublyLinkedList::ConstIterator::universalEnd())) { #ifdef HASHTABLE_DEBUG printf("bucket iterator init!\n"); #endif - const SinglyLinkedList& chain = m_table.m_buckets[0].chain; + const DoublyLinkedList& chain = m_table.m_buckets[0].chain; m_bucketIterator = chain.begin(); skipToNext(); @@ -198,7 +198,7 @@ public: const HashTable& m_table; unsigned m_bucketIndex { 0 }; bool m_isEnd { false }; - typename SinglyLinkedList::ConstIterator m_bucketIterator; + typename DoublyLinkedList::ConstIterator m_bucketIterator; }; ConstIterator begin() const { return ConstIterator(*this, false); }