private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveMininumKey(BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out KeyValuePair <TKey, TValue> min) { if (t.LeftChild == null) { min = t.Data; return(t.RightChild); } else { BinaryTreeNode <KeyValuePair <TKey, TValue> > left = RemoveMininumKey(t.LeftChild, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, left, t.RightChild)); } }
/// <summary> /// retruns the result of removing a binary tree(as a binary tree) /// </summary> /// <param name="key">key that is passed in</param> /// <param name="t">tree that is passed in</param> /// <param name="removed">tree that is going to be removed</param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(t); } else if (t.Data.Key.CompareTo(key) < 0)//trees data is less than the key { BinaryTreeNode <KeyValuePair <TKey, TValue> > thing = Remove(key, t.RightChild, out removed); BinaryTreeNode <KeyValuePair <TKey, TValue> > exit = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, thing); return(exit); } else if (t.Data.Key.CompareTo(key) > 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > leftThing = Remove(key, t.LeftChild, out removed); BinaryTreeNode <KeyValuePair <TKey, TValue> > exit = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, leftThing, t.RightChild); return(exit); } else { removed = true; if (t.RightChild == null) //i fliped this case with the last one { return(t.LeftChild); //retrun that child } else if (t.LeftChild == null) { return(t.RightChild);//retrun that child } else { KeyValuePair <TKey, TValue> tempKey = new KeyValuePair <TKey, TValue>(); BinaryTreeNode <KeyValuePair <TKey, TValue> > updateRight = RemoveMininumKey(t.RightChild, out tempKey); //buld a new tree min(data) as head original tree and right child BinaryTreeNode <KeyValuePair <TKey, TValue> > exit = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(tempKey, t.LeftChild, updateRight); return(exit);//should I create a tree with the parameters found above? } } }
/// <summary> /// Removes key given from dictionary using binary tree /// </summary> /// <param name="key">The Key</param> /// <param name="t">The tree</param> /// <param name="removed">true if remove occurred</param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { //checks that a tree exists if (t == null) { removed = false; return(null); } int comp = key.CompareTo(t.Data.Key); // if given key is equal to root's key if (comp == 0) { removed = true; //if either child is empty, return the other child if (t.LeftChild == null) { return(t.RightChild); } else if (t.RightChild == null) { return(t.LeftChild); } else { //build tree KeyValuePair <TKey, TValue> rmin; BinaryTreeNode <KeyValuePair <TKey, TValue> > rremoved = RemoveMininumKey(t.RightChild, out rmin); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(rmin, t.LeftChild, rremoved)); } } else if (comp < 0) { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); //return tree whose left child is the result of removing the given key from it } else { ///Otherwise, return a tree whose right child is the result of removing the given key from it. return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } }
/// <summary> /// /// </summary> /// <param name="key"></param> /// <param name="tree"></param> /// <param name="removed"></param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveNode(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > tree, out bool removed) { if (tree == null) { removed = false; return(tree); } int compare = tree.Data.Key.CompareTo(key); bool recursiveRemoved; if (compare < 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > rightUpdate = RemoveNode(key, tree.RightChild, out recursiveRemoved); removed = recursiveRemoved; return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(tree.Data, tree.LeftChild, rightUpdate)); } else if (compare > 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > leftUpdate = RemoveNode(key, tree.LeftChild, out recursiveRemoved); removed = recursiveRemoved; return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(tree.Data, leftUpdate, tree.RightChild)); } else { removed = true; if (tree.RightChild == null && tree.LeftChild == null) { return(null); } else if (tree.RightChild == null) { return(tree.LeftChild); } else if (tree.LeftChild == null) { return(tree.RightChild); } else { KeyValuePair <TKey, TValue> min; BinaryTreeNode <KeyValuePair <TKey, TValue> > updatedRight = FindMinimumKey(tree.RightChild, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, tree.LeftChild, updatedRight)); } } }
/// <summary> /// returns the minimum tree from a tree that is passed in. /// </summary> /// <param name="t">tree that is passed in </param> /// <param name="min">out parameter to be set(tree)</param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveMininumKey(BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out KeyValuePair <TKey, TValue> min) { if (t.LeftChild != null) //if the tree has a left { BinaryTreeNode <KeyValuePair <TKey, TValue> > lefty = RemoveMininumKey(t.LeftChild, out min); //left child BinaryTreeNode <KeyValuePair <TKey, TValue> > exit = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, lefty, t.RightChild); return(exit); } else//we are the min { min = t.Data; return(t.RightChild); } }
/// <summary> /// Removes the node at a given key from the tree. /// </summary> /// <param name="key"></param> /// <param name="t"></param> /// <param name="removed"></param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(null); } else { int comp = key.CompareTo(t.Data.Key); if (comp == 0) { removed = true; if (t.LeftChild == null) { return(t.RightChild); } else if (t.RightChild == null) { return(t.LeftChild); } else if (t.LeftChild != null && t.RightChild != null) { KeyValuePair <TKey, TValue> min; BinaryTreeNode <KeyValuePair <TKey, TValue> > r = RemoveMinimumKey(t, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, r)); } else { return(t); } } else if (comp < 0) { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); } else { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } } }
/// <summary> /// Moves the smallest node for given tree and returns the result /// </summary> /// <param name="t">BST to remove minimum from</param> /// <param name="min">out parameter holding K-V pair of minimum value in tree</param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveMinimumKey(BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out KeyValuePair <TKey, TValue> min) { if (t == null) { throw new ArgumentException(); } if (t.LeftChild == null) { min = t.Data; return(t.RightChild); } else { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, RemoveMinimumKey(t.LeftChild, out min), t.RightChild)); } }
/// <summary> /// Removes the given key from the provided tree noded and returns whether or not the pair was removed. /// </summary> /// <param name="key">The provided key to be removed</param> /// <param name="t">The given tree node</param> /// <param name="removed">True if the key was removed.</param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; BinaryTreeNode <KeyValuePair <TKey, TValue> > temp = null; return(temp); } else { float compare = key.CompareTo(t.Data.Key); if (compare == 0) { removed = true; if (t.LeftChild == null) { return(t.RightChild); } else if (t.RightChild == null) { return(t.LeftChild); } else { BinaryTreeNode <KeyValuePair <TKey, TValue> > newRightChild = RemoveMininumKey(t.RightChild, out KeyValuePair <TKey, TValue> min); BinaryTreeNode <KeyValuePair <TKey, TValue> > newNode = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, newRightChild); return(newNode); } } else if (compare < 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > newLeftChild = Remove(key, t.LeftChild, out removed); BinaryTreeNode <KeyValuePair <TKey, TValue> > newNode = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, newLeftChild, t.RightChild); return(newNode); } else { BinaryTreeNode <KeyValuePair <TKey, TValue> > newRightChild = Remove(key, t.RightChild, out removed); BinaryTreeNode <KeyValuePair <TKey, TValue> > newNode = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, newRightChild); return(newNode); } } }
private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveMininumKey(BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out KeyValuePair <TKey, TValue> min) { if (t.LeftChild != null) { BinaryTreeNode <KeyValuePair <TKey, TValue> > newLeft = RemoveMininumKey(t.LeftChild, out min); BinaryTreeNode <KeyValuePair <TKey, TValue> > updatedTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, newLeft, t.RightChild); return(updatedTree); } else { min = t.Data; return(t.RightChild); } }
private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(t); } else { int comp = key.CompareTo(t.Data.Key); if (comp == 0) { removed = true; //remove it if (t.LeftChild == null) { return(t.RightChild); } else if (t.RightChild == null) { return(t.LeftChild); } else { KeyValuePair <TKey, TValue> small; BinaryTreeNode <KeyValuePair <TKey, TValue> > moveUp = RemoveMininumKey(t.RightChild, out small); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(small, t.LeftChild, moveUp)); } } else if (comp < 0) { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); } else { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } } }
/// <summary> /// Removes the Node within the binary tree. /// </summary> /// <param name="key"></param> /// <param name="t"></param> /// <param name="removed"></param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(null); } int compare = key.CompareTo(t.Data.Key); if (compare == 0) { if (t.RightChild == null) { removed = true; return(t.LeftChild); } else if (t.LeftChild == null) { removed = true; return(t.RightChild); } else { removed = true; KeyValuePair <TKey, TValue> min; BinaryTreeNode <KeyValuePair <TKey, TValue> > right = RemoveMininumKey(t.RightChild, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, right)); } } else if (compare < 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > remove = Remove(key, t.LeftChild, out removed); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, remove, t.RightChild)); } else { BinaryTreeNode <KeyValuePair <TKey, TValue> > remove = Remove(key, t.RightChild, out removed); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, remove)); } }
/// <summary> /// removes the node /// </summary> /// <param name="key"></param> /// <param name="t"></param> /// <param name="removed"></param> /// <returns>the result of removing the node containing the given key from the given binary search tree.</returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(null); } if (key.CompareTo(t.Data.Key) == 0) { removed = true; if (t.LeftChild == null) { return(t.RightChild); } else if (t.RightChild == null) { return(t.LeftChild); } else { KeyValuePair <TKey, TValue> minKey; BinaryTreeNode <KeyValuePair <TKey, TValue> > Right = RemoveMininumKey(t.RightChild, out minKey); BinaryTreeNode <KeyValuePair <TKey, TValue> > binaryTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(minKey, t.LeftChild, Right); return(binaryTree); } } if (key.CompareTo(t.Data.Key) < 0) { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); } else { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } }
private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (key == null) { throw new ArgumentNullException(); } if (t == null) { removed = false; return(t); } BinaryTreeNode <KeyValuePair <TKey, TValue> > returnTree = null; int compareKey = key.CompareTo(t.Data.Key); if (compareKey > 0) { returnTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed)); return(returnTree); } else if (compareKey < 0) { returnTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild); return(returnTree); } else { KeyValuePair <TKey, TValue> min; removed = true; if (t.RightChild != null) { BinaryTreeNode <KeyValuePair <TKey, TValue> > tempNode = RemoveMininumKey(t.RightChild, out min); returnTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, tempNode); } else if (t.LeftChild != null) { BinaryTreeNode <KeyValuePair <TKey, TValue> > tempNode = RemoveMininumKey(t.LeftChild, out min); returnTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, tempNode, t.RightChild); } else { returnTree = null; } return(returnTree); } }
private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveMininumKey(BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out KeyValuePair <TKey, TValue> min) { BinaryTreeNode <KeyValuePair <TKey, TValue> > tempTree = null; if (t.LeftChild != null) { tempTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, RemoveMininumKey(t.LeftChild, out min), t.RightChild); return(tempTree); } else if (t.RightChild != null) { min = t.Data; tempTree = new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, null, t.RightChild); return(tempTree); } else { min = t.Data; return(tempTree = null); } }
/// <summary> /// Returns the result of removing the node containing the given key from the given binary search tree /// </summary> /// <param name="key">The key you want removed</param> /// <param name="t">The tree you are wanting k to be removed from</param> /// <param name="removed">Output of whether or not it was removed</param> /// <returns>The tree with the key removed</returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { //The tree is empty if (t == null) { removed = false; return(null); } else { int result = key.CompareTo(t.Data.Key); //The key we are looking for is at the root if (result == 0) { removed = true; //The left child is empty if (t.LeftChild == null) { return(t.RightChild); } //The right child is empty else if (t.RightChild == null) { return(t.LeftChild); } //Both children are non empty else { KeyValuePair <TKey, TValue> min; BinaryTreeNode <KeyValuePair <TKey, TValue> > right = RemoveMininumKey(t.RightChild, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, right)); } } //The key we are looking for is less than the key at the root else if (result < 0) { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); } //The key we are looking for is greater than the key at the root else { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } } }
/// <summary> /// Remove the given key and its associated value from the dictionary using the above method. /// </summary> /// <param name="k"></param> /// <returns> Whether the key was found </returns> public bool Remove(TKey k) { CheckKey(k); _elements = Remove(k, _elements, out bool removed); return(removed); }
/// <summary> /// Builds the result of performing a double rotate left on the binary tree /// described by the given root, left child, and right child. /// </summary> /// <param name="root">The data stored in the root of the original tree.</param> /// <param name="left">The left child of the root of the original tree.</param> /// <param name="right">The right child of the root of the original tree.</param> /// <returns>The result of performing a single rotate right on the tree described /// by the parameters.</returns> private static BinaryTreeNode <T> DoubleRotateLeft(T root, BinaryTreeNode <T> left, BinaryTreeNode <T> right) { BinaryTreeNode <T> newLeft = new BinaryTreeNode <T>(root, left, right.LeftChild.LeftChild); BinaryTreeNode <T> newRight = new BinaryTreeNode <T>(right.Data, right.LeftChild.RightChild, right.RightChild); return(new BinaryTreeNode <T>(right.LeftChild.Data, newLeft, newRight)); }
/// <summary> /// goes through the tree finds the minimum value and removes it /// </summary> /// <param name="t"></param> /// <param name="min"></param> /// <returns>updated tree</returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > RemoveMininumKey(BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out KeyValuePair <TKey, TValue> min) { if (t.LeftChild != null) { min = default(KeyValuePair <TKey, TValue>); BinaryTreeNode <KeyValuePair <TKey, TValue> > updated = RemoveMininumKey(t.LeftChild, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, updated, t.RightChild)); } else { min = t.Data; return(t.RightChild); } }
/// <summary> /// Adds the given key with the given associated value. /// If the given key is already in the dictionary, throws an /// InvalidOperationException. /// </summary> /// <param name="k">The key.</param> /// <param name="v">The value.</param> public void Add(TKey k, TValue v) { CheckKey(k); _elements = Add(_elements, k, v); }
/// <summary> /// looks to find the key that is to be removed, and removes it from the tree, updates tree /// </summary> /// <param name="key"></param> /// <param name="t"></param> /// <param name="removed"></param> /// <returns>updated tree if valid</returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(null); } else if (t.Data.Key.CompareTo(key) < 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > rightUpdate = Remove(key, t.RightChild, out removed); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, rightUpdate)); } else if (t.Data.Key.CompareTo(key) > 0) { BinaryTreeNode <KeyValuePair <TKey, TValue> > leftUpdate = Remove(key, t.LeftChild, out removed); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, leftUpdate, t.RightChild)); } else { removed = true; if (t.LeftChild == null && t.RightChild == null) { return(null); } else if (t.LeftChild != null && t.RightChild == null) { return(t.LeftChild); } else if (t.RightChild != null && t.LeftChild == null) { return(t.RightChild); } else { KeyValuePair <TKey, TValue> min; BinaryTreeNode <KeyValuePair <TKey, TValue> > updatedRight = RemoveMininumKey(t.RightChild, out min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, updatedRight)); } } }
/// <summary> /// Removes node containing given key from BST /// </summary> /// <param name="key">key being searched for</param> /// <param name="t">BST being searched</param> /// <param name="removed">Indicates if key was found</param> /// <returns></returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(null); } int comparison = key.CompareTo(t.Data.Key); if (comparison == 0) { removed = true; if (t.LeftChild == null) { return(t.RightChild); } else if (t.RightChild == null) { return(t.LeftChild); } else { KeyValuePair <TKey, TValue> minPair = new KeyValuePair <TKey, TValue>(); BinaryTreeNode <KeyValuePair <TKey, TValue> > result = RemoveMinimumKey(t.RightChild, out minPair); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(minPair, t.LeftChild, result)); } } if (comparison < 0) //key is less than current root { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); } if (comparison > 0) //key greater than current root { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } else { removed = false; return(null); } }
/// <summary> /// Returns the results of removing the node containing the given key from the given binary search tree. /// </summary> /// <param name="key">The key.</param> /// <param name="t">The binary search tree.</param> /// <param name="removed">Boolean value will return true if it is removed</param> /// <returns>Returns the new binary tree with the node removed.</returns> private static BinaryTreeNode <KeyValuePair <TKey, TValue> > Remove(TKey key, BinaryTreeNode <KeyValuePair <TKey, TValue> > t, out bool removed) { if (t == null) { removed = false; return(t); } int c = key.CompareTo(t.Data.Key); if (c == 0) { if (t.LeftChild == null) { removed = true; return(t.RightChild); } if (t.RightChild == null) { removed = true; return(t.LeftChild); } removed = true; BinaryTreeNode <KeyValuePair <TKey, TValue> > newRightChild = RemoveMininumKey(t.RightChild, out KeyValuePair <TKey, TValue> min); return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(min, t.LeftChild, newRightChild)); } else if (c < 0) { return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, Remove(key, t.LeftChild, out removed), t.RightChild)); } else { removed = false; return(new BinaryTreeNode <KeyValuePair <TKey, TValue> >(t.Data, t.LeftChild, Remove(key, t.RightChild, out removed))); } }