aboutsummaryrefslogtreecommitdiff
path: root/Ryujinx.Common/Collections/TreeDictionary.cs
diff options
context:
space:
mode:
Diffstat (limited to 'Ryujinx.Common/Collections/TreeDictionary.cs')
-rw-r--r--Ryujinx.Common/Collections/TreeDictionary.cs987
1 files changed, 987 insertions, 0 deletions
diff --git a/Ryujinx.Common/Collections/TreeDictionary.cs b/Ryujinx.Common/Collections/TreeDictionary.cs
new file mode 100644
index 00000000..a44f650c
--- /dev/null
+++ b/Ryujinx.Common/Collections/TreeDictionary.cs
@@ -0,0 +1,987 @@
+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;
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-10 16:43:00 +0000