mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-12-05 01:32:00 +00:00
06aa8a7578
* Implement TreeMap from scratch. Begin implementation of MemoryBlockManager * Implement GetFreePosition using MemoryBlocks * Implementation of Memory Management using a Tree. Still some issues to work around, but promising thus far. * Resolved invalid mapping issue. Performance appears promising. * Add tick metrics * Use the logger instead * Use debug loggin instead of info. * Remove unnecessary code. Add descriptions of added functions. * Improve memory allocation even further. As well as improve speed of position fetching. * Add TreeDictionary to Ryujinx Commons Removed Unnecessary Usigns * Add a Performance Profiler + Improve ReserveFixed * Begin transition to allocation in nvdrv * Create singleton nvmemallocator * Moved Allocation into Nv Related Files As requested by gdkchan, any allocation of memory has been moved into the driver files. Mapping remains in the GPU MemoryManager. * Remove unnecessary usings * Add missing descriptions * Correct descriptions * Fix formatting. * Remove unnecessary whitespace * Formatting / Convention Updates * Changes / Fixes Made syntax and convention changes as requested by gdkchan. Fixed an issue where IsRegionUsed would return the wrong boolean. Fixed an issue where GetFreePosition was asked for an address instead of a size. * Undo commenting of Assert in shader cache * Update Ryujinx.Common/Collections/TreeDictionary.cs Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Resolved many suggestions * Implement Improved TreeDictionary Based off of Pseudo code and custom implementations. * Rename _set to _dictionary * Remove unused code * Remove unused code. * Remove unnecessary MapLow function. * Resolve data-structure based issues * Make adjustments to memory management. Deactive de-allocation for now, it causes more harm than good. * Minor refactorings + Re-implement deallocation Also cleaned up unnecessary code. * Add Tests for TreeDictionary * Update data structure to properly balance the tree * Experimental Implementation: 1. Reduce Time to Next Node to O(1) Runtime 2. Reduce While Loop Ct To 2 (In Most Cases) * Address issues w/ Deallocating Memory * Final Build + Fully Implement Dictionary Interface for new Data Structure + Cover All Memory Allocation Edge Cases, particularly w/ Games that De-Allocate a lot. * Minor Corrections Give TreeDictionary its own count (do not depend on inner dictionary) Properly remove adjacent allocations * Add AsList * Fix bug where internal dictionary wasn't being updated w/ new node for overwritten key. * Address comments in review. * Fix issue where block wouldn't break out (Fixes UE4 issues) * Update descriptions * Update descriptions * Reduce Node visibility to protect TreeDictionary Integrity + Remove usage of struct. * Update tests to use new TreeDictionary implementation. * Remove usage of dictionary in TreeDictionary * Refactoring / Renaming * Remove unneeded memoryblock class. * Add space for while * Add space for if * Formatting / descriptions * Clarified some descriptions * Reduce visibility of memory allocator * Edit method names to make more sense as memory blocks are no longer in use. * Make names consistent. * Protect against npe when sucessorof is called against keys that don't exist. (Not in use by memory manager, this is for other prs that might use this data structure) * Possible edge-case resolve * Update Ryujinx.Common/Collections/TreeDictionary.cs Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Update Ryujinx.HLE/HOS/Services/Nv/NvMemoryAllocator.cs Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Reduce # of unnecessary duplicate variables / Reduce visibility of variables only internally used. * Rename count to _count * Update Description of Add method. * Fix copypasta * Address comments * Address comments * Remove whitespace * Address comments, condense variables. * Consolidate vars * Fix whitespace. * Nit * Fix exception msg * Fix arrayIndex check * Fix arrayIndex check + indexer * Remove whitespace from cast Co-authored-by: gdkchan <gab.dark.100@gmail.com>
987 lines
32 KiB
C#
987 lines
32 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
namespace Ryujinx.Common.Collections
|
|
{
|
|
/// <summary>
|
|
/// Dictionary that provides the ability for O(logN) Lookups for keys that exist in the Dictionary, and O(logN) lookups for keys immediately greater than or less than a specified key.
|
|
/// </summary>
|
|
/// <typeparam name="K">Key</typeparam>
|
|
/// <typeparam name="V">Value</typeparam>
|
|
public class TreeDictionary<K, V> : IDictionary<K, V> where K : IComparable<K>
|
|
{
|
|
private const bool Black = true;
|
|
private const bool Red = false;
|
|
private Node<K, V> _root = null;
|
|
private int _count = 0;
|
|
public TreeDictionary() { }
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Returns the value of the node whose key is <paramref name="key"/>, or the default value if no such node exists.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node value to get</param>
|
|
/// <returns>Value associated w/ <paramref name="key"/></returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
public V Get(K key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
|
|
Node<K, V> node = GetNode(key);
|
|
|
|
if (node == null)
|
|
{
|
|
return default;
|
|
}
|
|
|
|
return node.Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a new node into the tree whose key is <paramref name="key"/> key and value is <paramref name="value"/>.
|
|
/// <br></br>
|
|
/// <b>Note:</b> Adding the same key multiple times will cause the value for that key to be overwritten.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node to add</param>
|
|
/// <param name="value">Value of the node to add</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> or <paramref name="value"/> are null</exception>
|
|
public void Add(K key, V value)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
if (null == value)
|
|
{
|
|
throw new ArgumentNullException(nameof(value));
|
|
}
|
|
|
|
Insert(key, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the node whose key is <paramref name="key"/> from the tree.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node to remove</param>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
public void Remove(K key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
if (Delete(key) != null)
|
|
{
|
|
_count--;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the value whose key is equal to or immediately less than <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="key">Key for which to find the floor value of</param>
|
|
/// <returns>Key of node immediately less than <paramref name="key"/></returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
public K Floor(K key)
|
|
{
|
|
Node<K, V> node = FloorNode(key);
|
|
if (node != null)
|
|
{
|
|
return node.Key;
|
|
}
|
|
return default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the node whose key is equal to or immediately greater than <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="key">Key for which to find the ceiling node of</param>
|
|
/// <returns>Key of node immediately greater than <paramref name="key"/></returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
public K Ceiling(K key)
|
|
{
|
|
Node<K, V> node = CeilingNode(key);
|
|
if (node != null)
|
|
{
|
|
return node.Key;
|
|
}
|
|
return default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the value whose key is immediately greater than <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="key">Key to find the successor of</param>
|
|
/// <returns>Value</returns>
|
|
public K SuccessorOf(K key)
|
|
{
|
|
Node<K, V> node = GetNode(key);
|
|
if (node != null)
|
|
{
|
|
Node<K, V> successor = SuccessorOf(node);
|
|
|
|
return successor != null ? successor.Key : default;
|
|
}
|
|
return default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the value whose key is immediately less than <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="key">Key to find the predecessor of</param>
|
|
/// <returns>Value</returns>
|
|
public K PredecessorOf(K key)
|
|
{
|
|
Node<K, V> node = GetNode(key);
|
|
if (node != null)
|
|
{
|
|
Node<K, V> predecessor = PredecessorOf(node);
|
|
|
|
return predecessor != null ? predecessor.Key : default;
|
|
}
|
|
return default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all the nodes in the dictionary as key/value pairs into <paramref name="list"/>.
|
|
/// <br></br>
|
|
/// The key/value pairs will be added in Level Order.
|
|
/// </summary>
|
|
/// <param name="list">List to add the tree pairs into</param>
|
|
public List<KeyValuePair<K, V>> AsLevelOrderList()
|
|
{
|
|
List<KeyValuePair<K, V>> list = new List<KeyValuePair<K, V>>();
|
|
|
|
Queue<Node<K, V>> nodes = new Queue<Node<K, V>>();
|
|
|
|
if (this._root != null)
|
|
{
|
|
nodes.Enqueue(this._root);
|
|
}
|
|
while (nodes.Count > 0)
|
|
{
|
|
Node<K, V> node = nodes.Dequeue();
|
|
list.Add(new KeyValuePair<K, V>(node.Key, node.Value));
|
|
if (node.Left != null)
|
|
{
|
|
nodes.Enqueue(node.Left);
|
|
}
|
|
if (node.Right != null)
|
|
{
|
|
nodes.Enqueue(node.Right);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds all the nodes in the dictionary into <paramref name="list"/>.
|
|
/// <br></br>
|
|
/// The nodes will be added in Sorted by Key Order.
|
|
/// </summary>
|
|
public List<KeyValuePair<K, V>> AsList()
|
|
{
|
|
List<KeyValuePair<K, V>> list = new List<KeyValuePair<K, V>>();
|
|
|
|
Queue<Node<K, V>> nodes = new Queue<Node<K, V>>();
|
|
|
|
if (this._root != null)
|
|
{
|
|
nodes.Enqueue(this._root);
|
|
}
|
|
while (nodes.Count > 0)
|
|
{
|
|
Node<K, V> node = nodes.Dequeue();
|
|
list.Add(new KeyValuePair<K, V>(node.Key, node.Value));
|
|
if (node.Left != null)
|
|
{
|
|
nodes.Enqueue(node.Left);
|
|
}
|
|
if (node.Right != null)
|
|
{
|
|
nodes.Enqueue(node.Right);
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
#endregion
|
|
#region Private Methods (BST)
|
|
|
|
/// <summary>
|
|
/// Retrieve the node reference whose key is <paramref name="key"/>, or null if no such node exists.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node to get</param>
|
|
/// <returns>Node reference in the tree</returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
private Node<K, V> GetNode(K key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
|
|
Node<K, V> node = _root;
|
|
while (node != null)
|
|
{
|
|
int cmp = key.CompareTo(node.Key);
|
|
if (cmp < 0)
|
|
{
|
|
node = node.Left;
|
|
}
|
|
else if (cmp > 0)
|
|
{
|
|
node = node.Right;
|
|
}
|
|
else
|
|
{
|
|
return node;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserts a new node into the tree whose key is <paramref name="key"/> and value is <paramref name="value"/>.
|
|
/// <br></br>
|
|
/// Adding the same key multiple times will overwrite the previous value.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node to insert</param>
|
|
/// <param name="value">Value of the node to insert</param>
|
|
private void Insert(K key, V value)
|
|
{
|
|
Node<K, V> newNode = BSTInsert(key, value);
|
|
RestoreBalanceAfterInsertion(newNode);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Insertion Mechanism for a Binary Search Tree (BST).
|
|
/// <br></br>
|
|
/// Iterates the tree starting from the root and inserts a new node where all children in the left subtree are less than <paramref name="key"/>, and all children in the right subtree are greater than <paramref name="key"/>.
|
|
/// <br></br>
|
|
/// <b>Note: </b> If a node whose key is <paramref name="key"/> already exists, it's value will be overwritten.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node to insert</param>
|
|
/// <param name="value">Value of the node to insert</param>
|
|
/// <returns>The inserted Node</returns>
|
|
private Node<K, V> BSTInsert(K key, V value)
|
|
{
|
|
Node<K, V> parent = null;
|
|
Node<K, V> node = _root;
|
|
|
|
while (node != null)
|
|
{
|
|
parent = node;
|
|
int cmp = key.CompareTo(node.Key);
|
|
if (cmp < 0)
|
|
{
|
|
node = node.Left;
|
|
}
|
|
else if (cmp > 0)
|
|
{
|
|
node = node.Right;
|
|
}
|
|
else
|
|
{
|
|
node.Value = value;
|
|
return node;
|
|
}
|
|
}
|
|
Node<K, V> newNode = new Node<K, V>(key, value, parent);
|
|
if (newNode.Parent == null)
|
|
{
|
|
_root = newNode;
|
|
}
|
|
else if (key.CompareTo(parent.Key) < 0)
|
|
{
|
|
parent.Left = newNode;
|
|
}
|
|
else
|
|
{
|
|
parent.Right = newNode;
|
|
}
|
|
_count++;
|
|
return newNode;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes <paramref name="key"/> from the dictionary, if it exists.
|
|
/// </summary>
|
|
/// <param name="key">Key of the node to delete</param>
|
|
/// <returns>The deleted Node</returns>
|
|
private Node<K, V> Delete(K key)
|
|
{
|
|
// O(1) Retrieval
|
|
Node<K, V> nodeToDelete = GetNode(key);
|
|
|
|
if (nodeToDelete == null) return null;
|
|
|
|
Node<K, V> replacementNode;
|
|
|
|
if (LeftOf(nodeToDelete) == null || RightOf(nodeToDelete) == null)
|
|
{
|
|
replacementNode = nodeToDelete;
|
|
}
|
|
else
|
|
{
|
|
replacementNode = PredecessorOf(nodeToDelete);
|
|
}
|
|
|
|
Node<K, V> tmp = LeftOf(replacementNode) ?? RightOf(replacementNode);
|
|
|
|
if (tmp != null)
|
|
{
|
|
tmp.Parent = ParentOf(replacementNode);
|
|
}
|
|
|
|
if (ParentOf(replacementNode) == null)
|
|
{
|
|
_root = tmp;
|
|
}
|
|
|
|
else if (replacementNode == LeftOf(ParentOf(replacementNode)))
|
|
{
|
|
ParentOf(replacementNode).Left = tmp;
|
|
}
|
|
else
|
|
{
|
|
ParentOf(replacementNode).Right = tmp;
|
|
}
|
|
|
|
if (replacementNode != nodeToDelete)
|
|
{
|
|
nodeToDelete.Key = replacementNode.Key;
|
|
nodeToDelete.Value = replacementNode.Value;
|
|
}
|
|
|
|
if (tmp != null && ColorOf(replacementNode) == Black)
|
|
{
|
|
RestoreBalanceAfterRemoval(tmp);
|
|
}
|
|
|
|
return replacementNode;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the node with the largest key where <paramref name="node"/> is considered the root node.
|
|
/// </summary>
|
|
/// <param name="node">Root Node</param>
|
|
/// <returns>Node with the maximum key in the tree of <paramref name="node"/></returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
|
|
private static Node<K, V> Maximum(Node<K, V> node)
|
|
{
|
|
if (node == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(node));
|
|
}
|
|
Node<K, V> tmp = node;
|
|
while (tmp.Right != null)
|
|
{
|
|
tmp = tmp.Right;
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the node with the smallest key where <paramref name="node"/> is considered the root node.
|
|
/// </summary>
|
|
/// <param name="node">Root Node</param>
|
|
/// <returns>Node with the minimum key in the tree of <paramref name="node"/></returns>
|
|
///<exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
|
|
private static Node<K, V> Minimum(Node<K, V> node)
|
|
{
|
|
if (node == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(node));
|
|
}
|
|
Node<K, V> tmp = node;
|
|
while (tmp.Left != null)
|
|
{
|
|
tmp = tmp.Left;
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the node whose key immediately less than or equal to <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="key">Key for which to find the floor node of</param>
|
|
/// <returns>Node whose key is immediately less than or equal to <paramref name="key"/>, or null if no such node is found.</returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
private Node<K, V> FloorNode(K key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
Node<K, V> tmp = _root;
|
|
|
|
while (tmp != null)
|
|
{
|
|
int cmp = key.CompareTo(tmp.Key);
|
|
if (cmp > 0)
|
|
{
|
|
if (tmp.Right != null)
|
|
{
|
|
tmp = tmp.Right;
|
|
}
|
|
else
|
|
{
|
|
return tmp;
|
|
}
|
|
}
|
|
else if (cmp < 0)
|
|
{
|
|
if (tmp.Left != null)
|
|
{
|
|
tmp = tmp.Left;
|
|
}
|
|
else
|
|
{
|
|
Node<K, V> parent = tmp.Parent;
|
|
Node<K, V> ptr = tmp;
|
|
while (parent != null && ptr == parent.Left)
|
|
{
|
|
ptr = parent;
|
|
parent = parent.Parent;
|
|
}
|
|
return parent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return tmp;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the node whose key is immediately greater than or equal to than <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="key">Key for which to find the ceiling node of</param>
|
|
/// <returns>Node whose key is immediately greater than or equal to <paramref name="key"/>, or null if no such node is found.</returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
|
|
private Node<K, V> CeilingNode(K key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
Node<K, V> tmp = _root;
|
|
|
|
while (tmp != null)
|
|
{
|
|
int cmp = key.CompareTo(tmp.Key);
|
|
if (cmp < 0)
|
|
{
|
|
if (tmp.Left != null)
|
|
{
|
|
tmp = tmp.Left;
|
|
}
|
|
else
|
|
{
|
|
return tmp;
|
|
}
|
|
}
|
|
else if (cmp > 0)
|
|
{
|
|
if (tmp.Right != null)
|
|
{
|
|
tmp = tmp.Right;
|
|
}
|
|
else
|
|
{
|
|
Node<K, V> parent = tmp.Parent;
|
|
Node<K, V> ptr = tmp;
|
|
while (parent != null && ptr == parent.Right)
|
|
{
|
|
ptr = parent;
|
|
parent = parent.Parent;
|
|
}
|
|
return parent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return tmp;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the node with the key immediately greater than <paramref name="node"/>.Key.
|
|
/// </summary>
|
|
/// <param name="node">Node to find the successor of</param>
|
|
/// <returns>Successor of <paramref name="node"/></returns>
|
|
private static Node<K, V> SuccessorOf(Node<K, V> node)
|
|
{
|
|
if (node.Right != null)
|
|
{
|
|
return Minimum(node.Right);
|
|
}
|
|
Node<K, V> parent = node.Parent;
|
|
while (parent != null && node == parent.Right)
|
|
{
|
|
node = parent;
|
|
parent = parent.Parent;
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the node whose key immediately less than <paramref name="node"/>.Key.
|
|
/// </summary>
|
|
/// <param name="node">Node to find the predecessor of</param>
|
|
/// <returns>Predecessor of <paramref name="node"/></returns>
|
|
private static Node<K, V> PredecessorOf(Node<K, V> node)
|
|
{
|
|
if (node.Left != null)
|
|
{
|
|
return Maximum(node.Left);
|
|
}
|
|
Node<K, V> parent = node.Parent;
|
|
while (parent != null && node == parent.Left)
|
|
{
|
|
node = parent;
|
|
parent = parent.Parent;
|
|
}
|
|
return parent;
|
|
}
|
|
#endregion
|
|
#region Private Methods (RBL)
|
|
|
|
private void RestoreBalanceAfterRemoval(Node<K, V> balanceNode)
|
|
{
|
|
Node<K, V> ptr = balanceNode;
|
|
|
|
while (ptr != _root && ColorOf(ptr) == Black)
|
|
{
|
|
if (ptr == LeftOf(ParentOf(ptr)))
|
|
{
|
|
Node<K, V> sibling = RightOf(ParentOf(ptr));
|
|
|
|
if (ColorOf(sibling) == Red)
|
|
{
|
|
SetColor(sibling, Black);
|
|
SetColor(ParentOf(ptr), Red);
|
|
RotateLeft(ParentOf(ptr));
|
|
sibling = RightOf(ParentOf(ptr));
|
|
}
|
|
if (ColorOf(LeftOf(sibling)) == Black && ColorOf(RightOf(sibling)) == Black)
|
|
{
|
|
SetColor(sibling, Red);
|
|
ptr = ParentOf(ptr);
|
|
}
|
|
else
|
|
{
|
|
if (ColorOf(RightOf(sibling)) == Black)
|
|
{
|
|
SetColor(LeftOf(sibling), Black);
|
|
SetColor(sibling, Red);
|
|
RotateRight(sibling);
|
|
sibling = RightOf(ParentOf(ptr));
|
|
}
|
|
SetColor(sibling, ColorOf(ParentOf(ptr)));
|
|
SetColor(ParentOf(ptr), Black);
|
|
SetColor(RightOf(sibling), Black);
|
|
RotateLeft(ParentOf(ptr));
|
|
ptr = _root;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Node<K, V> sibling = LeftOf(ParentOf(ptr));
|
|
|
|
if (ColorOf(sibling) == Red)
|
|
{
|
|
SetColor(sibling, Black);
|
|
SetColor(ParentOf(ptr), Red);
|
|
RotateRight(ParentOf(ptr));
|
|
sibling = LeftOf(ParentOf(ptr));
|
|
}
|
|
if (ColorOf(RightOf(sibling)) == Black && ColorOf(LeftOf(sibling)) == Black)
|
|
{
|
|
SetColor(sibling, Red);
|
|
ptr = ParentOf(ptr);
|
|
}
|
|
else
|
|
{
|
|
if (ColorOf(LeftOf(sibling)) == Black)
|
|
{
|
|
SetColor(RightOf(sibling), Black);
|
|
SetColor(sibling, Red);
|
|
RotateLeft(sibling);
|
|
sibling = LeftOf(ParentOf(ptr));
|
|
}
|
|
SetColor(sibling, ColorOf(ParentOf(ptr)));
|
|
SetColor(ParentOf(ptr), Black);
|
|
SetColor(LeftOf(sibling), Black);
|
|
RotateRight(ParentOf(ptr));
|
|
ptr = _root;
|
|
}
|
|
}
|
|
}
|
|
SetColor(ptr, Black);
|
|
}
|
|
|
|
private void RestoreBalanceAfterInsertion(Node<K, V> balanceNode)
|
|
{
|
|
SetColor(balanceNode, Red);
|
|
while (balanceNode != null && balanceNode != _root && ColorOf(ParentOf(balanceNode)) == Red)
|
|
{
|
|
if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode))))
|
|
{
|
|
Node<K, V> sibling = RightOf(ParentOf(ParentOf(balanceNode)));
|
|
|
|
if (ColorOf(sibling) == Red)
|
|
{
|
|
SetColor(ParentOf(balanceNode), Black);
|
|
SetColor(sibling, Black);
|
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
|
balanceNode = ParentOf(ParentOf(balanceNode));
|
|
}
|
|
else
|
|
{
|
|
if (balanceNode == RightOf(ParentOf(balanceNode)))
|
|
{
|
|
balanceNode = ParentOf(balanceNode);
|
|
RotateLeft(balanceNode);
|
|
}
|
|
SetColor(ParentOf(balanceNode), Black);
|
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
|
RotateRight(ParentOf(ParentOf(balanceNode)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Node<K, V> sibling = LeftOf(ParentOf(ParentOf(balanceNode)));
|
|
|
|
if (ColorOf(sibling) == Red)
|
|
{
|
|
SetColor(ParentOf(balanceNode), Black);
|
|
SetColor(sibling, Black);
|
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
|
balanceNode = ParentOf(ParentOf(balanceNode));
|
|
}
|
|
else
|
|
{
|
|
if (balanceNode == LeftOf(ParentOf(balanceNode)))
|
|
{
|
|
balanceNode = ParentOf(balanceNode);
|
|
RotateRight(balanceNode);
|
|
}
|
|
SetColor(ParentOf(balanceNode), Black);
|
|
SetColor(ParentOf(ParentOf(balanceNode)), Red);
|
|
RotateLeft(ParentOf(ParentOf(balanceNode)));
|
|
}
|
|
}
|
|
}
|
|
SetColor(_root, Black);
|
|
}
|
|
|
|
private void RotateLeft(Node<K, V> node)
|
|
{
|
|
if (node != null)
|
|
{
|
|
Node<K, V> right = RightOf(node);
|
|
node.Right = LeftOf(right);
|
|
if (LeftOf(right) != null)
|
|
{
|
|
LeftOf(right).Parent = node;
|
|
}
|
|
right.Parent = ParentOf(node);
|
|
if (ParentOf(node) == null)
|
|
{
|
|
_root = right;
|
|
}
|
|
else if (node == LeftOf(ParentOf(node)))
|
|
{
|
|
ParentOf(node).Left = right;
|
|
}
|
|
else
|
|
{
|
|
ParentOf(node).Right = right;
|
|
}
|
|
right.Left = node;
|
|
node.Parent = right;
|
|
}
|
|
}
|
|
|
|
private void RotateRight(Node<K, V> node)
|
|
{
|
|
if (node != null)
|
|
{
|
|
Node<K, V> left = LeftOf(node);
|
|
node.Left = RightOf(left);
|
|
if (RightOf(left) != null)
|
|
{
|
|
RightOf(left).Parent = node;
|
|
}
|
|
left.Parent = node.Parent;
|
|
if (ParentOf(node) == null)
|
|
{
|
|
_root = left;
|
|
}
|
|
else if (node == RightOf(ParentOf(node)))
|
|
{
|
|
ParentOf(node).Right = left;
|
|
}
|
|
else
|
|
{
|
|
ParentOf(node).Left = left;
|
|
}
|
|
left.Right = node;
|
|
node.Parent = left;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Safety-Methods
|
|
|
|
// These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against nullpointerexceptions.
|
|
|
|
/// <summary>
|
|
/// Returns the color of <paramref name="node"/>, or Black if it is null.
|
|
/// </summary>
|
|
/// <param name="node">Node</param>
|
|
/// <returns>The boolean color of <paramref name="node"/>, or black if null</returns>
|
|
private static bool ColorOf(Node<K, V> node)
|
|
{
|
|
return node == null || node.Color;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the color of <paramref name="node"/> node to <paramref name="color"/>.
|
|
/// <br></br>
|
|
/// This method does nothing if <paramref name="node"/> is null.
|
|
/// </summary>
|
|
/// <param name="node">Node to set the color of</param>
|
|
/// <param name="color">Color (Boolean)</param>
|
|
private static void SetColor(Node<K, V> node, bool color)
|
|
{
|
|
if (node != null)
|
|
{
|
|
node.Color = color;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the left node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
|
|
/// </summary>
|
|
/// <param name="node">Node to retrieve the left child from</param>
|
|
/// <returns>Left child of <paramref name="node"/></returns>
|
|
private static Node<K, V> LeftOf(Node<K, V> node)
|
|
{
|
|
return node?.Left;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the right node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
|
|
/// </summary>
|
|
/// <param name="node">Node to retrieve the right child from</param>
|
|
/// <returns>Right child of <paramref name="node"/></returns>
|
|
private static Node<K, V> RightOf(Node<K, V> node)
|
|
{
|
|
return node?.Right;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the parent node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
|
|
/// </summary>
|
|
/// <param name="node">Node to retrieve the parent from</param>
|
|
/// <returns>Parent of <paramref name="node"/></returns>
|
|
private static Node<K, V> ParentOf(Node<K, V> node)
|
|
{
|
|
return node?.Parent;
|
|
}
|
|
#endregion
|
|
|
|
#region Interface Implementations
|
|
|
|
// Method descriptions are not provided as they are already included as part of the interface.
|
|
public bool ContainsKey(K key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
return GetNode(key) != null;
|
|
}
|
|
|
|
bool IDictionary<K, V>.Remove(K key)
|
|
{
|
|
int count = _count;
|
|
Remove(key);
|
|
return count > _count;
|
|
}
|
|
|
|
public bool TryGetValue(K key, [MaybeNullWhen(false)] out V value)
|
|
{
|
|
if (null == key)
|
|
{
|
|
throw new ArgumentNullException(nameof(key));
|
|
}
|
|
Node<K, V> node = GetNode(key);
|
|
value = node != null ? node.Value : default;
|
|
return node != null;
|
|
}
|
|
|
|
public void Add(KeyValuePair<K, V> item)
|
|
{
|
|
if (item.Key == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(item.Key));
|
|
}
|
|
|
|
Add(item.Key, item.Value);
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_root = null;
|
|
_count = 0;
|
|
}
|
|
|
|
public bool Contains(KeyValuePair<K, V> item)
|
|
{
|
|
if (item.Key == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Node<K, V> node = GetNode(item.Key);
|
|
if (node != null)
|
|
{
|
|
return node.Key.Equals(item.Key) && node.Value.Equals(item.Value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex)
|
|
{
|
|
if (arrayIndex < 0 || array.Length - arrayIndex < this.Count)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(arrayIndex));
|
|
}
|
|
|
|
SortedList<K, V> list = GetKeyValues();
|
|
|
|
int offset = 0;
|
|
|
|
for (int i = arrayIndex; i < array.Length && offset < list.Count; i++)
|
|
{
|
|
array[i] = new KeyValuePair<K, V>(list.Keys[i], list.Values[i]);
|
|
offset++;
|
|
}
|
|
}
|
|
|
|
public bool Remove(KeyValuePair<K, V> item)
|
|
{
|
|
Node<K, V> node = GetNode(item.Key);
|
|
|
|
if (node == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (node.Value.Equals(item.Value))
|
|
{
|
|
int count = _count;
|
|
Remove(item.Key);
|
|
return count > _count;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
|
|
{
|
|
return GetKeyValues().GetEnumerator();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetKeyValues().GetEnumerator();
|
|
}
|
|
|
|
public int Count => _count;
|
|
|
|
public ICollection<K> Keys => GetKeyValues().Keys;
|
|
|
|
public ICollection<V> Values => GetKeyValues().Values;
|
|
|
|
public bool IsReadOnly => false;
|
|
|
|
public V this[K key]
|
|
{
|
|
get => Get(key);
|
|
set => Add(key, value);
|
|
}
|
|
|
|
#endregion
|
|
#region Private Interface Helper Methods
|
|
|
|
/// <summary>
|
|
/// Returns a sorted list of all the node keys / values in the tree.
|
|
/// </summary>
|
|
/// <returns>List of node keys</returns>
|
|
private SortedList<K, V> GetKeyValues()
|
|
{
|
|
SortedList<K, V> set = new SortedList<K, V>();
|
|
Queue<Node<K, V>> queue = new Queue<Node<K, V>>();
|
|
if (_root != null)
|
|
{
|
|
queue.Enqueue(_root);
|
|
}
|
|
|
|
while (queue.Count > 0)
|
|
{
|
|
Node<K, V> node = queue.Dequeue();
|
|
set.Add(node.Key, node.Value);
|
|
if (null != node.Left)
|
|
{
|
|
queue.Enqueue(node.Left);
|
|
}
|
|
if (null != node.Right)
|
|
{
|
|
queue.Enqueue(node.Right);
|
|
}
|
|
}
|
|
|
|
return set;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a node in the TreeDictionary which contains a key and value of generic type K and V, respectively.
|
|
/// </summary>
|
|
/// <typeparam name="K">Key of the node</typeparam>
|
|
/// <typeparam name="V">Value of the node</typeparam>
|
|
internal class Node<K, V>
|
|
{
|
|
internal bool Color = true;
|
|
internal Node<K, V> Left = null;
|
|
internal Node<K, V> Right = null;
|
|
internal Node<K, V> Parent = null;
|
|
internal K Key;
|
|
internal V Value;
|
|
|
|
public Node(K key, V value, Node<K, V> parent)
|
|
{
|
|
this.Key = key;
|
|
this.Value = value;
|
|
this.Parent = parent;
|
|
}
|
|
}
|
|
}
|