public void InOrderPredecessor_RootRight() { AVLNode<int> rootRight = new AVLNode<int>(50) { Right = new AVLNode<int>(75) }; Assert.IsNull(rootRight.InOrderPredecessor); }
public void InOrderPredecessor_RootLeft() { AVLNode<int> rootLeft = new AVLNode<int>(50) { Left = new AVLNode<int>(25) }; Assert.AreEqual<int>(25, rootLeft.InOrderPredecessor.Value); }
public void InOrderPredecessor_RootLeftRight() { AVLNode<int> rootLeftRight = new AVLNode<int>(50) { Left = new AVLNode<int>(25) { Right = new AVLNode<int>(30) } }; Assert.AreEqual<int>(30, rootLeftRight.InOrderPredecessor.Value); }
public void AssertValidTree_InvalidBalance_Left() { var root = new AVLNode<int>(100); root.Left = new AVLNode<int>(50); root.Right = new AVLNode<int>(150); root.Left.Left = new AVLNode<int>(30); root.Left.Left.Left = new AVLNode<int>(20); AVLTree<int> bst = new AVLTree<int>(); bst.Root = root; bst.AssertValidTree(); }
public void ResetHeight() { var node = new AVLNode<int>(20); Assert.AreEqual<int>(0, node.Height); node.Left = new AVLNode<int>(10); Assert.AreEqual<int>(0, node.Height); node.ResetHeight(); Assert.AreEqual<int>(1, node.Height); }
private int HeightOfNode(AVLNode n) { return(n is null ? -1 : n.Height); }
public void IsLeaf_False_Right() { var node = new AVLNode<int>(50); node.Right = new AVLNode<int>(70); Assert.IsFalse(node.IsLeaf); }
/// <summary> /// clearing the tree /// </summary> public void Clear() { entries.Clear(); AVLroot = null; count = 0; }
private bool IsRigthHeavy(AVLNode n) { return(CalculateBalancedFactor(n) < -1 ? true : false); }
public AVLNode GetNearestRight(TKey key) { return(AVLNode.GetNearestRight(_root, key, _comparison)); }
public AVLNode(TKey key, TValue value, AVLNode parent) { Key = key; Value = value; Parent = parent; }
internal static void AddItem(TKey key, TValue value, QueuedAVLTree <TKey, TValue> tree, ref int elementCount) { if (!tree.ContainsKey(key)) { tree.queue.CheckRoom(tree); if (tree.head == null) { tree.head = new AVLNode(key, value, tree); elementCount++; goto LukeIDeletedYourFather; } } AVLNode headNode = tree.head; int compare = key.CompareTo(headNode.key); while (true) { if (compare < 0) { if (headNode.left == null) { headNode.left = new AVLNode(key: key, value: value, tree: tree) { head = headNode, isLeft = true }; headNode._depthL = 1; AVLNode.BalanceBubbleUp(headNode, tree); elementCount++; break; } else { headNode = headNode.left; compare = key.CompareTo(headNode.key); } } else if (compare > 0) { if (headNode.right == null) { headNode.right = new AVLNode(key: key, value: value, tree: tree) { head = headNode, isLeft = false }; headNode._depthR = 1; AVLNode.BalanceBubbleUp(headNode, tree); elementCount++; break; } else { headNode = headNode.right; compare = key.CompareTo(headNode.key); } } else { headNode.value = value; break; } } LukeIDeletedYourFather :; }
private void SetHeight(AVLNode node) { node.height = 1 + Math.Max(GetHeight(node.leftChild), GetHeight(node.rightChild)); }
private int Height(AVLNode <T> node) { return(-1); }
internal static void RemoveNode(AVLNode node, QueuedAVLTree <TKey, TValue> tree, bool callFromQueue = false) { if (!callFromQueue) { tree.queue.Dequeue(node.linkedElement, tree); } if (node.right == null && node.left == null) // no children { if (node.head == null) // was the top node { tree.head = null; } else { if (node.isLeft) { node.head.left = null; node.head._depthL = 0; } else { node.head.right = null; node.head._depthR = 0; } AVLNode.BalanceSelfBubbleUp(node.head, tree); } } else if (node.right == null || node.left == null) // one child { AVLNode child = node.right != null ? node.right : node.left; if (node.head == null) // was the top node { tree.head = child; child.head = null; } else { child.isLeft = node.isLeft; if (node.isLeft) { node.head.left = child; child.head = node.head; node.head._depthL -= 1; } else { node.head.right = child; child.head = node.head; node.head._depthR -= 1; } AVLNode.BalanceSelfBubbleUp(node.head, tree); } } else // two children :O { AVLNode child = node.right, childhead = node.head; while (child.left != null) { childhead = child; child = child.left; } if (childhead != node.head) { if (child.right != null) { childhead.left = child.right; child.right.head = childhead; child.right.isLeft = true; childhead._depthL--; } else { childhead.left = null; childhead._depthL = 0; } child.right = node.right; } child.left = node.left; child.left.head = child; child.head = node.head; child.isLeft = node.isLeft; if (node.head == null) { tree.head = child; } else { if (node.isLeft) { node.head.left = child; } else { node.head.right = child; } } if (childhead == node.head) { AVLNode.BalanceSelfBubbleUp(child, tree); } else { child.right.head = child; AVLNode.BalanceSelfBubbleUp(childhead, tree); } } tree.count--; }
/// <summary> /// /// Complexity: O(1). /// </summary> public void Clear() { root = null; }
/// <summary> /// /// Complexity: O(log n) /// </summary> public T GetMin() { AVLNode <T> result = GetMinNode(); return(result != null ? result.Value : default(T)); }
void Swap(AVLNode <T> a, AVLNode <T> b) { if (a == null || b == null) { return; } bool aWasLeft = a.Parent != null && a.Parent.Left == a; bool bWasLeft = b.Parent != null && b.Parent.Left == b; AVLNode <T> tempLeft = a.Left; AVLNode <T> tempRight = a.Right; AVLNode <T> tempParent = a.Parent; int tempHeight = a.Height; a.Left = b.Left; a.Right = b.Right; a.Parent = b.Parent; a.Height = b.Height; b.Left = tempLeft; b.Right = tempRight; b.Parent = tempParent; b.Height = tempHeight; // if 'b' was the left node, right node or parent of 'a' if (b.Left == b) { b.Left = a; } else if (b.Right == b) { b.Right = a; } else if (b.Parent == b) { b.Parent = a; } // if 'a' was the left node, right node or parent of 'b' if (a.Left == a) { a.Left = b; } else if (a.Right == a) { a.Right = b; } else if (a.Parent == a) { a.Parent = b; } // swapping all pointers as in the following lines // keeps all AVLNodes the user might store valid if (a.Left != null) { a.Left.Parent = a; } if (a.Right != null) { a.Right.Parent = a; } if (b.Left != null) { b.Left.Parent = b; } if (b.Right != null) { b.Right.Parent = b; } if (a.Parent != null && bWasLeft) { a.Parent.Left = a; } else if (a.Parent != null) { a.Parent.Right = a; } if (b.Parent != null && aWasLeft) { b.Parent.Left = b; } else if (b.Parent != null) { b.Parent.Right = b; } }
public void Bound(TKey key, out AVLNode lower, out AVLNode upper) { AVLNode.Bound(_root, key, _comparison, out lower, out upper); }
private int GetHeight(AVLNode node) { return(node == null ? -1 : node.height); }
public void ToString_RootRight() { AVLNode<int> node = new AVLNode<int>(50) { Right = new AVLNode<int>(75), }; Assert.AreEqual<string>("50; Left=null; Right=75", node.ToString()); }
private bool IsLeftHeavy(AVLNode node) { return(GetBalanceFactor(node) > 1); }
public void Add(TKey key, TValue value) { AVLNode.Add(ref _root, key, value, _comparison); _count++; }
private bool IsRightHeavy(AVLNode node) { return(GetBalanceFactor(node) < -1); }
/// <summary> /// removing node with key /// </summary> /// <param name="key"></param> /// <returns></returns> public bool Remove(TKey key) { AVLNode node = AVLroot; while (node != null) { if (key.CompareTo(node.Key) < 0) { node = node.Left; } else if (key.CompareTo(node.Key) > 0) { node = node.Right; } else { AVLNode l = node.Left; AVLNode r = node.Right; if (l == null) { if (r == null) { if (node == AVLroot) { AVLroot = null; } else { AVLNode nodeP = node.Parent; if (nodeP.Left == node) { nodeP.Left = null; RemoveBalanceFactor(nodeP, -1); } else { nodeP.Right = null; RemoveBalanceFactor(nodeP, 1); } } } else { Change(node, r); RemoveBalanceFactor(node, 0); } } else if (r == null) { Change(node, l); RemoveBalanceFactor(node, 0); } else { AVLNode temp = r; if (temp.Left == null) { AVLNode parent = node.Parent; temp.Parent = parent; temp.Left = l; temp.balanceFactor = node.balanceFactor; if (l != null) { l.Parent = temp; } if (node == AVLroot) { AVLroot = temp; } else { if (parent.Left == node) { parent.Left = temp; } else { parent.Right = temp; } } RemoveBalanceFactor(temp, 1); } else { while (temp.Left != null) { temp = temp.Left; } AVLNode parent = node.Parent; AVLNode tempParent = temp.Parent; AVLNode tempRight = temp.Right; if (tempParent.Left == temp) { tempParent.Left = tempRight; } else { tempParent.Right = tempRight; } if (tempRight != null) { tempRight.Parent = tempParent; } temp.Parent = parent; temp.Left = l; temp.balanceFactor = node.balanceFactor; temp.Right = r; r.Parent = temp; if (l != null) { l.Parent = temp; } if (node == AVLroot) { AVLroot = temp; } else { if (parent.Left == node) { parent.Left = temp; } else { parent.Right = temp; } } RemoveBalanceFactor(tempParent, -1); } } count--; entries.Remove(new AVLNode(key, this[key])); return(true); } } return(false); }
private int GetBalanceFactor(AVLNode node) { return(node == null ? 0 : GetHeight(node.leftChild) - GetHeight(node.rightChild)); }
private int CalculateBalancedFactor(AVLNode n) { return(n is null ? 0 : HeightOfNode(n.LeftChild) - HeightOfNode(n.RigthChild)); }
public void Insert(int value) { root = Insert(root, value); }
private bool IsLeftHeavy(AVLNode n) { return(CalculateBalancedFactor(n) > 1 ? true : false); }
internal static int GetCount(AVLNode node) { return(1 + (node.left == null ? 0 : GetCount(node.left)) + (node.right == null ? 0 : GetCount(node.right))); }
public void IsLeaf_False_Left() { var node = new AVLNode<int>(50); node.Left = new AVLNode<int>(20); Assert.IsFalse(node.IsLeaf); }
internal static void RemoveNode(AVLNode node, object[] HashMap, int hash, ref int elementCount) { if (node.right == null && node.left == null) // no children { if (node.head == null) // was the top node { HashMap[hash] = null; } else { if (node.isLeft) { node.head.left = null; node.head._depthL = 0; } else { node.head.right = null; node.head._depthR = 0; } AVLNode.BalanceSelfBubbleUp(node.head, HashMap, hash); } } else if (node.right == null || node.left == null) // one child { AVLNode child = node.right != null ? node.right : node.left; if (node.head == null) // was the top node { HashMap[hash] = child; child.head = null; } else { child.isLeft = node.isLeft; if (node.isLeft) { node.head.left = child; child.head = node.head; node.head._depthL -= 1; } else { node.head.right = child; child.head = node.head; node.head._depthR -= 1; } AVLNode.BalanceSelfBubbleUp(node.head, HashMap, hash); } } else // two children :O { AVLNode child = node.right, childhead = node.head; while (child.left != null) { childhead = child; child = child.left; } if (childhead != node.head) { if (child.right != null) { childhead.left = child.right; child.right.head = childhead; child.right.isLeft = true; childhead._depthL--; } else { childhead.left = null; childhead._depthL = 0; } child.right = node.right; } child.left = node.left; child.left.head = child; child.head = node.head; child.isLeft = node.isLeft; if (node.head == null) { HashMap[hash] = child; } else { if (node.isLeft) { node.head.left = child; } else { node.head.right = child; } } if (childhead == node.head) { AVLNode.BalanceSelfBubbleUp(child, HashMap, hash); } else { child.right.head = child; AVLNode.BalanceSelfBubbleUp(childhead, HashMap, hash); } } elementCount--; }
public void IsLeaf_True() { var node = new AVLNode<int>(50); Assert.IsTrue(node.IsLeaf); }
public void Clear() { _root = null; _count = 0; }
public void RotateRight_FullTree() { var node = new AVLNode<int>(100); node.Left = new AVLNode<int>(50); node.Right = new AVLNode<int>(150); node.Left.Left = new AVLNode<int>(25); node.Left.Right = new AVLNode<int>(75); node.Right.Left = new AVLNode<int>(125); node.Right.Right = new AVLNode<int>(175); node = node.RotateRight(); Assert.AreEqual<int>(50, node.Value); Assert.AreEqual<int>(25, node.Left.Value); Assert.AreEqual<int>(100, node.Right.Value); Assert.AreEqual<int>(75, node.Right.Left.Value); Assert.AreEqual<int>(150, node.Right.Right.Value); Assert.AreEqual<int>(125, node.Right.Right.Left.Value); Assert.AreEqual<int>(175, node.Right.Right.Right.Value); }
public void InOrderSuccessor_RootLeft() { AVLNode<int> rootLeft = new AVLNode<int>(50) { Left = new AVLNode<int>(25) }; Assert.IsNull(rootLeft.InOrderSuccessor); }
public void ToString_RootLeft() { AVLNode<int> node = new AVLNode<int>(50) { Left = new AVLNode<int>(25), }; Assert.AreEqual<string>("50; Left=25; Right=null", node.ToString()); }
public void AssertValidTree_InvalidChildren() { var root = new AVLNode<int>(100); root.Left = new AVLNode<int>(150); AVLTree<int> bst = new AVLTree<int>(); bst.Root = root; bst.AssertValidTree(); }
/// <inheritdoc /> public TValue this[TKey key] { get { if (key == null) { return(default(TValue)); } int hash = Math.Abs(key.GetHashCode()) % _size; if (HashMap[hash] == null) { return(default(TValue)); } else if (HashMap[hash] is KeyValuePair <TKey, TValue> ) { if (((KeyValuePair <TKey, TValue>)HashMap[hash]).Key.Equals(key)) { return(((KeyValuePair <TKey, TValue>)HashMap[hash]).Value); } else { return(default(TValue)); } } else // if HashMap[hash] is an AVL Node search for it { AVLNode node = (AVLNode)HashMap[hash]; int compare = key.CompareTo(node.key); while (true) { if (compare < 0) { node = node.left; if (node != null) { compare = key.CompareTo(node.key); } else { return(default(TValue)); } } else if (compare > 0) { node = node.right; if (node != null) { compare = key.CompareTo(node.key); } else { return(default(TValue)); } } else { return(node.value); } } } } set { Add(new KeyValuePair <TKey, TValue>(key, value)); } }
public IEnumerator <AVLNode> GetEnumerator() { return(AVLNode.EnumerateRoot(_root).GetEnumerator()); }
public void InOrderSuccessor_Leaf() { AVLNode<int> leaf = new AVLNode<int>(50); Assert.IsNull(leaf.InOrderSuccessor); }
private static void UpdateDepth(AVLNode node) { node._depthL = node.left == null ? 0 : Math.Max(node.left._depthL, node.left._depthR) + 1; node._depthR = node.right == null ? 0 : Math.Max(node.right._depthL, node.right._depthR) + 1; }
public void InOrderSuccessor_RootRight() { AVLNode<int> rootRight = new AVLNode<int>(50) { Right = new AVLNode<int>(75) }; Assert.AreEqual<int>(75, rootRight.InOrderSuccessor.Value); }
private AVLNode Double_Rotate_Right(AVLNode p) { p.right = Rotate_Right(p.right); p = Rotate_Left(p); return(p); }
public AVLNode Delete(AVLNode p, int x) { AVLNode q, r, w; if (p != null) // daca nodul curent este diferit de NULL { if (x < p.key) //cheia care se doreste stearsa este mai mica decat informatia din nod { p.left = Delete(p.left, x); // se cauta cheia de sters in subarborele stang al nodului curent } else if (x > p.key) // daca cheia este mai mare { p.right = Delete(p.right, x); // se cauta in subarborele drept } else { //daca cheia este egala cu informatia din nodul curent Debug.Log("yess"); q = p; //un nod q devine p if (q.right == null) // daca copilul drept al lui q eate NULL { p = q.left; // atunci p devine q->stanga } else if (q.left == null) //altfel daca copilul stang al lui q este NULL { p = q.right; // p devine q->dreapta } else { w = q.left; //altfel w este copilul stanga al lui q r = q; // r devine q if (w.right != null) // daca copilul drept al lui w nun este NULL { while (w.right != null) { r = w; w = w.right; } p.key = w.key; q = w; r.right = w.left; r = p.left; w = w.left; if (r != null) { while ((r != w) && (r != null)) { r = echilibrare(r); r = r.right; } } } else { p.key = w.key; p.left = w.left; q = w; } } q = null; // se sterge q } } if (p != null) { p = echilibrare(p); // se echilibreaza p daca nu este NULL } else { p = new AVLNode(); } return(p); }
private static void ViewAVLLayer(AVLNode<int, int> node, Queue<AVLNode<int, int>> que) { if (node.Left != null) que.Enqueue(node.Left); if (node.Right != null) que.Enqueue(node.Right); Console.Write("{0} ", node.Key); if (que.Count > 0) { ViewAVLLayer(que.Dequeue(), que); } }