/** * Add a number in the subtree of this node */ public BT_Node Insert(int _value) { BT_Node newNode = new BT_Node(this, _value); if (_value < this.Value) { // Smaller value, insert it into the left subtree if (this.Left == null) this.Left = newNode; else this.Left.Insert(_value); } else { // Larger value, insert it in the right subtree if (this.Right == null) this.Right = newNode; else this.Right.Insert(_value); } return newNode; }
private BT_Node Search(BT_Node n, int _value) { if (this.Root.Value == _value) return Root; else return n.Value <= _value ? StepRight(n, _value) : StepLeft(n, _value); }
/** * Double rotate binary tree node: first right child * with its left child; then node k1 with new right child. * For AVL trees, this is a double rotation for case 3. * Update heights, then return new root. */ private BT_Node RotateRightRight(BT_Node _node) { _node.Right = RotateLeft(_node.Right); return RotateRight(_node); }
/** * Rotate binary tree node with right child. * For AVL trees, this is a single rotation for case 4. * Update heights, then return new root. */ private BT_Node RotateRight(BT_Node _node) { BT_Node temp = _node.Right; _node.Right = temp.Left; temp.Left = _node; return temp; }
private bool Remove(int _value) { if (Root == null) { return false; } else { if (Root.Value == _value) { BT_Node node = new BT_Node(null, 0); node.Left = root; bool result = root.Remove(_value, node); root = node.Left; return result; } else { return root.Remove(_value, null); } } }
private int CountRecusive(BT_Node node) { int elements = 0; if (node != null) elements = 1 + CountRecusive(node.Left) + CountRecusive(node.Right); return elements; }
/** * Inserts the value into the binary search tree */ public void Insert(int _value) { if (Root == null) { Root = new BT_Node(null, _value); } else { BT_Node nodeComairer = Root; BT_Node newNode = new BT_Node(null, _value); while (newNode != null) { // Go Left if (newNode.Value < nodeComairer.Value) { if (nodeComairer.Left == null) { newNode.Parent = nodeComairer; nodeComairer.Left = newNode; InsertBalance(newNode.Parent); return; } else { nodeComairer = nodeComairer.Left; } } // Go Right else if (newNode.Value > nodeComairer.Value) { if (nodeComairer.Right == null) { newNode.Parent = nodeComairer; nodeComairer.Right = newNode; InsertBalance(newNode.Parent); return; } else { nodeComairer = nodeComairer.Right; } } else { InsertBalance(Root.Insert(_value).Parent); } } } }
/** * Print all values that lie between min and max in order (inclusive) */ public void PrintInRange(BT_Node _node, int _min, int _max) { if (_node == null) return; if ( _node.Value > _min) PrintInRange(_node.Left, _min, _max); if (_node.Value >= _min && _node.Value <= _max) Console.Write(_node.Value + ", "); if (_node.Value < _max) PrintInRange(_node.Right, _min, _max); }
public void Rebalance(BT_Node _node) { // substrect by one for the parm node is counted as well int depthLeft = (this.Depth(Root.Left) - 1); int depthRight = (this.Depth(Root.Right) - 1); int balance = depthLeft - depthRight; if ((depthLeft - depthRight) < 1) { return; } // go left else if ((depthLeft - depthRight) <= 2) { if ((depthLeft - depthRight) == 1) RotateRight(_node); else RotateLeftLeft(_node); return; } // go Right else if ((depthRight - depthLeft) <= 2) { if ((depthRight - depthLeft) == 1) RotateLeft(_node); else RotateRightRight(_node); return; } }
public int minValue(BT_Node node) { if (node.Left == null) return node.Value; else return minValue(node.Left); }
/** * Print all the values in the tree in order */ public void Print(BT_Node node) { if (node == null) return; Print(node.Left); Console.Write(node.Value + " "); Print(node.Right); }
/** * Returns the smallest value in the tree (or -1 if tree is empty) */ public BT_Node Min(BT_Node node) { if (node != null) { if (node.Left != null && node.Left.Value <= node.Value) return Min(node.Left); else return node; } else { node = new BT_Node(); node.Value = -1; return node; } }
/** * Returns the largest value in the tree (or -1 if tree is empty) */ public BT_Node Max(BT_Node node) { if (node != null) { if (node.Right != null && node.Right.Value > node.Value) return Max(node.Right); else return node; } else { node = new BT_Node(); node.Value = -1; return node; } }
public void InsertBalance(BT_Node newNode) { // substrect by one for the parm node is counted as well int depthLeft = (this.Depth(Root.Left)); int depthRight = (this.Depth(Root.Right)); int balance = depthLeft - depthRight; while (newNode != null) { if (balance > -2 && balance < 2) { return; } // go left else if (balance >= 2) { if (balance == 2) RotateRight(newNode); else RotateRightRight(newNode); } // go Right else if (balance <= -2) { if (balance == -2) RotateLeft(newNode); else RotateLeftLeft(newNode); } if (newNode != null) //balance += (newNode.Parent.Left == newNode ? 1 : -1); balance -= 1; newNode = newNode.Parent; } }
private BT_Node StepRight(BT_Node n, int _value) { if (n.Value == _value) return n; else if (n.Left != null && n.Value <= _value) return StepLeft(n.Left, _value); else if (n.Right != null && n.Value > _value) return StepRight(n.Right, _value); else return null; }
public void remove(int x) { root = remove(x, root); }
public BT_Node(BT_Node _parrent, int _value) { this.Value = _value; this.Parent = _parrent; }
public BT_Node remove(int x, BT_Node _node) { return null; //if (_node == null) //{ // return null; //} //Console.WriteLine("Remove starts... " + _node.Value + " and " + x); //if (x.CompareTo(_node.Value) < 0) //{ // _node.Left = remove(x, _node.Left); // int l = _node.Left != null ? Depth(_node.Left) : 0; // if ((_node.Right != null) && (_node.Right.height - l >= 2)) // { // int rightHeight = _node.Right.Right != null ? _node.Right.Right.height : 0; // int leftHeight = _node.Right.Left != null ? _node.Right.Left.height : 0; // if (rightHeight >= leftHeight) // _node = RotateLeft(_node); // else // _node = RotateRightRight(_node); // } //} //else if (x.CompareTo(_node.Value) > 0) //{ // _node.Right = remove(x, _node.Right); // int r = _node.Right != null ? _node.Right.height : 0; // if ((_node.Left != null) && (_node.Left.height - r >= 2)) // { // int leftHeight = _node.Left.Left != null ? _node.Left.Left.height : 0; // int rightHeight = _node.Left.Right != null ? _node.Left.Right.height : 0; // if (leftHeight >= rightHeight) // _node = RotateRight(_node); // else // _node = RotateLeftLeft(_node); // } //} ///* // Here, we have ended up when we are node which shall be removed. // Check if there is a left-hand node, if so pick out the largest element out, and move down to the root. // */ //else if (_node.Left != null) //{ // _node.Value = Max(_node.Left).Value; // remove(_node.Value, _node.Left); // if ((_node.Right != null) && (_node.Right.height - _node.Left.height >= 2)) // { // int rightHeight = _node.Right.right != null ? _node.Right.right.height : 0; // int leftHeight = _node.Right.Left != null ? _node.Right.Left.height : 0; // if (rightHeight >= leftHeight) // _node = RotateLeft(_node); // else // _node = RotateRightRight(_node); // } //} //else // _node = (_node.Left != null) ? _node.Left : _node.Right; //if (_node != null) //{ // int leftHeight = _node.Left != null ? _node.Left.height : 0; // int rightHeight = _node.Right != null ? _node.Right.height : 0; // _node.height = Math.Max(leftHeight, rightHeight) + 1; //} //return _node; }
public bool Remove(int _value, BT_Node parent) { if (_value < this.value) { if (left != null) return left.Remove(_value, this); else return false; } else if (_value > this.value) { if (right != null) return right.Remove(_value, this); else return false; } else { if (left != null && right != null) { this.value = right.minValue(); right.Remove(this.value, this); } else if (parent.left == this) { parent.left = (left != null) ? left : right; } else if (parent.right == this) { parent.right = (left != null) ? left : right; } return true; } }
/** * Returns how many levels deep the deepest level in the tree is * (the empty tree is 0 levels deep, the tree with only one root node is 1 deep) * @return */ public int Depth(BT_Node node) { if (node == null) { return 0; } else { // compute the depth of each subtree int lDepth = Depth(node.Left); int rDepth = Depth(node.Right); // use the larger one if (lDepth > rDepth) return (lDepth + 1); else return (rDepth + 1); } }