private Tuple <BinaryNode <int>, BinaryNode <int> > FindNode(int value, BinaryNode <int> node, BinaryNode <int> parent) { BinaryNode <int> target = null; if (node != null) { if (value == node.value) { return(new Tuple <BinaryNode <int>, BinaryNode <int> >(node, parent)); } else if (value > node.value) { return(FindNode(value, node.right, node)); } else { return(FindNode(value, node.left, node)); } } else { return(null); } }
public bool RemoveNode(int value) { if (value < 0) { return(false); } bool found = false; bool isRoot = false; bool isRightChild = false; BinaryNode <int> parent; BinaryNode <int> target = FindWithParent(value, out parent); BinaryNode <int> newNode = null; BinaryNode <int> leftMostChildParent = null; if (parent == null) { isRoot = true; } else { isRightChild = target.value > parent.value; } //if it has no right child if (target.right == null) { //and it hasn't left too if (target.left == null) { if (isRoot) { Root = null; } else { if (isRightChild) { parent.right = null; } else { parent.left = null; } } found = true; } //the target has a left child only (no right of course) else { if (isRoot) { Root = target.left; } else { if (isRightChild) { parent.right = target.left; } else { target.right.left = target.left; } } found = true; } } //has a right child //it can have left child of course but our focus is on the right child else { //that right child has a left child if (target.right.left != null) { BinaryNode <int> leftMostChild = target.right; //get most left child while (leftMostChild.left.left != null) { leftMostChild = leftMostChild.left; } //to be able to get the parent of the left most child to remove it is pointer to our new target (which is its left child) leftMostChildParent = leftMostChild; leftMostChild = leftMostChild.left; leftMostChildParent.left = null; if (isRoot) { Root = leftMostChild; Root.left = target.left; Root.right = target.right; } else { if (isRightChild) { parent.right = leftMostChild; parent.right.right = target.right; parent.right.left = target.left; } else { parent.left = leftMostChild; parent.left.right = target.right; parent.left.left = target.left; } } found = true; } //that right child doesn't have a left child else { if (isRoot) { Root = target.right; Root.left = target.left; } else { if (isRightChild) { parent.right = target.right; parent.right.left = target.left; } else { //replace the node with its right child parent.left = target.right; //connects the node with any left child it was connected to before (parent.left is our new node) parent.left.left = target.left; } } found = true; } } return(found); }
/// <summary> /// Constructor. /// </summary> public BinaryTree() { count = 0; root = null; }
private void myRoot(BinaryNode <T> root) { this.root = root; }
private void Add(BinaryNode <T> newElement, BinaryNode <T> root) { if (root == null) { this.SetRoot(newElement); count++; this.root.SetPadre(null); } else { BinaryNode <T> binaryNode = this.root; while (binaryNode != null) { int compare = newElement.Value.CompareTo(binaryNode.Value); if (compare < 0) { BinaryNode <T> left = binaryNode.GetLeft(); if (left == null) { binaryNode.SetLeft(newElement); binaryNode.GetLeft().SetPadre(binaryNode); count++; InsertBalance(binaryNode, 1); return; } else { binaryNode = left; } } else { if (compare > 0) { BinaryNode <T> right = binaryNode.GetRight(); if (right == null) { binaryNode.SetRight(newElement); binaryNode.GetRight().SetPadre(binaryNode); count++; InsertBalance(binaryNode, -1); return; } else { binaryNode = right; } } else { binaryNode.Value = newElement.Value; return; } } } } }
public void Delete(int data) { Root = RecursivelyDelete(Root, data); }
public AVLTree() { count = 0; root = null; }
public BinaryNode(K key, V value, BinaryNode left, BinaryNode right) { this.Record = new KeyValuePair <K, V>(key, value); this.Left = left; this.Right = right; }
public bool Remove(K key) { BinaryNode parent = default(BinaryNode); BinaryNode lastVisited = default(BinaryNode); BinaryNode located = this.TraverseTo(this.root, key, out parent, out lastVisited); if (located == null) { return(false); } else { if (parent == null) { if (this.NodeIsLeaf(this.root)) { this.root = null; } else if (this.root.Left != null && this.root.Right != null) { this.TwoChildRemove(this.root); } else if (this.root.Left == null) { this.root = this.root.Right; } else { this.root = this.root.Left; } } else { if (parent.Left != null && parent.Left.Record.Key.Equals(key)) { if (this.NodeIsLeaf(located)) { parent.Left = null; } else if (located.Left != null && located.Right != null) { this.TwoChildRemove(parent.Left); } else if (located.Left == null) { parent.Left = parent.Left.Right; } else { parent.Left = parent.Left.Left; } } else { if (this.NodeIsLeaf(located)) { parent.Right = null; } else if (located.Left != null && located.Right != null) { this.TwoChildRemove(parent.Right); } else if (located.Left == null) { parent.Right = parent.Right.Right; } else { parent.Right = parent.Right.Left; } } } this.Count--; return(true); } }
public void Clear() { this.root = null; this.Count = 0; }
private BinaryNode TraverseTo(BinaryNode start, K key, out BinaryNode parent, out BinaryNode lastVisited) { BinaryNode previous = null; BinaryNode current = start; while ((current != null && !current.Record.Key.Equals(key)) && !this.NodeIsLeaf(current)) { if (key.CompareTo(current.Record.Key) < 0) { if (current.Left == null) { break; } previous = current; current = current.Left; } else { if (current.Right == null) { break; } previous = current; current = current.Right; } } parent = previous; lastVisited = current; if (current != null && current.Record.Key.Equals(key)) { return(current); } else { return(null); } }