public void AssertValidTree_InvalidChildren() { var root = new BinarySearchTreeNode<int>(100); root.Left = new BinarySearchTreeNode<int>(150); BinarySearchTree<int> bst = new BinarySearchTree<int>(); bst.Root = root; bst.AssertValidTree(); }
public void Height_2_RightRight() { BinarySearchTreeNode<int> root = new BinarySearchTreeNode<int>(100); root.Left = new BinarySearchTreeNode<int>(50); root.Right = new BinarySearchTreeNode<int>(150); root.Right.Right = new BinarySearchTreeNode<int>(160); Assert.AreEqual<int>(2, root.Height); }
public void Height_2_FullSecondLevel() { BinarySearchTreeNode<int> root = new BinarySearchTreeNode<int>(100); root.Left = new BinarySearchTreeNode<int>(50); root.Right = new BinarySearchTreeNode<int>(150); root.Left.Left = new BinarySearchTreeNode<int>(40); root.Left.Right = new BinarySearchTreeNode<int>(60); root.Right.Left = new BinarySearchTreeNode<int>(110); root.Right.Right = new BinarySearchTreeNode<int>(160); Assert.AreEqual<int>(2, root.Height); }
public void Height_3_LeftLeftLeft() { BinarySearchTreeNode<int> root = new BinarySearchTreeNode<int>(100); root.Left = new BinarySearchTreeNode<int>(50); root.Right = new BinarySearchTreeNode<int>(150); root.Left.Left = new BinarySearchTreeNode<int>(40); root.Left.Right = new BinarySearchTreeNode<int>(60); root.Right.Left = new BinarySearchTreeNode<int>(110); root.Right.Right = new BinarySearchTreeNode<int>(160); root.Left.Left.Left = new BinarySearchTreeNode<int>(30); Assert.AreEqual<int>(3, root.Height); }
public BinarySearchTreeNode <T> RotateRL() { if (IsRightEmpty()) { throw new SBTNodeEmptyException(true); } else if (Left.IsLeftEmpty()) { throw new SBTNodeEmptyException(false); } BinarySearchTreeNode <T> pNode = this; BinarySearchTreeNode <T> cNode = pNode.Right; pNode.ChangeRightSubtree(RotateLL()); pNode.RotateRR(); return(cNode); }
public void RebuildBinarySearchTreeFromPreOrderOnValueRange() { var list = new List <int> { 43, 23, 37, 29, 31, 41, 47, 53 }; var result = Solution.RebuildBinarySearchTreeFromPreOrderOnValueRange(list); var I = new BinarySearchTreeNode <int> { Data = 43 }; var J = new BinarySearchTreeNode <int> { Data = 23 }; var K = new BinarySearchTreeNode <int> { Data = 37 }; var L = new BinarySearchTreeNode <int> { Data = 29 }; var M = new BinarySearchTreeNode <int> { Data = 31 }; var N = new BinarySearchTreeNode <int> { Data = 41 }; var O = new BinarySearchTreeNode <int> { Data = 47 }; var P = new BinarySearchTreeNode <int> { Data = 53 }; I.Left = J; J.Right = K; K.Left = L; L.Right = M; K.Right = N; I.Right = O; O.Right = P; result.Should().BeEquivalentTo(I); }
public void Insert(T data) { BinarySearchTreeNode <T> new_node = new BinarySearchTreeNode <T>(data); if (_rtnd == null) { _rtnd = new_node; return; } BinarySearchTreeNode <T> parent = _rtnd; U dkey = _gkey(data); U pkey = _gkey(parent.Data); while (true) { if (dkey.CompareTo(pkey) < 0) { if (parent.IsLeftEmpty()) { parent.Left = new_node; return; } else { parent = parent.Left; pkey = _gkey(parent.Data); } } else if (dkey.CompareTo(pkey) > 0) { if (parent.IsRightEmpty()) { parent.Right = new_node; return; } else { parent = parent.Right; pkey = _gkey(parent.Data); } } else { throw new KeyOverlapException(); } } }
private void buttonDelete_Click(object sender, EventArgs e) { if (textBoxInput.Text.Trim().Length == 0) { return; } string[] lines = Regex.Split(textBoxInput.Text, ","); BinarySearchTreeNode <int> toFocus; try { toFocus = tree.Search(Array.ConvertAll <string, int>(lines, int.Parse).Last()); if (toFocus.HasParent) { selectedNode = toFocus.Parent; } foreach (int val in Array.ConvertAll <string, int>(lines, int.Parse)) { if (!tree.Delete(val)) { MessageBox.Show(val + " may not be in tree", "Tree prompt"); } } } catch (Exception ex) when( ex is System.FormatException || ex is System.NullReferenceException) { MessageBox.Show("Input error", "Please check your input"); } finally { if (tree.Root == null) { selectedNode = null; } Draw(); textBoxInput.Clear(); textBoxInput.Focus(); } }
public IEnumerator GetEnumerator() { Stack stack = new Stack(); stack.Push(this.root); while (stack.Count > 0) { BinarySearchTreeNode tempNode = (BinarySearchTreeNode)stack.Pop(); yield return(tempNode.value); if (tempNode.right != null) { stack.Push(tempNode.right); } if (tempNode.left != null) { stack.Push(tempNode.left); } } }
public static BinarySearchTreeNode <int> FindFirstGreaterThanK(BinarySearchTreeNode <int> tree, int k) { var subtree = tree; BinarySearchTreeNode <int> firstSoFar = null; while (subtree != null) { if (subtree.Data > k) { firstSoFar = subtree; subtree = subtree.Left; } else // Root and all keys in left-subtree are <= k, so skip them. { subtree = subtree.Right; } } return(firstSoFar); }
private int?FindMaximum(BinarySearchTreeNode Head) { if (Head == null) { return(null); } if (Head.right == null) { return(Head.val); } Int64 x = Int64.MinValue; int a = 1; if (a > x) { } return(FindMaximum(Head.right)); }
public BSTForm() { InitializeComponent(); bool Debug = false; if (Debug) { tree.Insert(63); tree.Insert(38); tree.Insert(97); tree.Insert(66); tree.Insert(31); selectedNode = tree.Root; } panel1.AutoScroll = true; panel1.Controls.Add(pictureBox1); pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize; }
public void Insert(T value) { if (head == null) { head = new BinarySearchTreeNode(value); } else { BinarySearchTreeNode parent = null; BinarySearchTreeNode current = head; int compareResult; do { parent = current; compareResult = current.Value.value.CompareTo(value); if (compareResult > 0) { current = current.FirstChild; } else if (compareResult == 0) { current.Increment(); return; } else { current = current.SecondChild; } } while (current != null); if (compareResult > 0) { parent.FirstChild = new BinarySearchTreeNode(value); } else { parent.SecondChild = new BinarySearchTreeNode(value); } } }
public void Remove(int value) { if (value == Root.Value) { if (Root.IsLeaf()) { Root = null; } else if (Root.Left == null && Root.Right != null) { Root = Root.Right; } else if (Root.Left != null && Root.Right == null) { Root = Root.Left; } else { if (Root.Left.Right != null) { int temp = Root.Left.Right.Value; Root.Left.Remove(temp, Root); Root.Value = temp; } else { int temp = Root.Left.Value; Root.Value = temp; Root.Left.Remove(temp, Root); } } } else if (value > Root.Value) { Root.Right.Remove(value, Root); } else { Root.Left.Remove(value, Root); } }
public bool Insert(T dataToInsert) { if (Root == null) { Root = new BinarySearchTreeNode(dataToInsert); Count++; return(true); } else { if (Root.Insert(dataToInsert, AcceptDuplicates)) { Count++; return(true); } else { return(false);//send a message to the developer to tell him why } } }
public static bool IsValidBstNode(BinarySearchTreeNode <int> node) { if (node == null) { return(true); } if (node.Left == null && node.Right == null) { return(true); } if (node.Left != null && node.Left.Item > node.Item) { return(false); } if (node.Right != null && node.Right.Item < node.Item) { return(false); } return(true); }
public static BinarySearchTreeNode <int> AncestorOfTwoNodesIterative(int node1Data, int node2Data, BinarySearchTree <int> bst) { // Make sure that node1 has the smaller of the 2 nodes if (node1Data > node2Data) { int temp = node2Data; node2Data = node1Data; node1Data = temp; } // Make sure that node1 and node2 are present in the Binary Search Tree BinarySearchTreeNode <int> node1 = bst.SearchBSTIterative(node1Data); BinarySearchTreeNode <int> node2 = bst.SearchBSTIterative(node2Data); if (node1 == null || node2 == null) { return(null); // The node is not present in the BST } BinarySearchTreeNode <int> currentNode = bst.Head; while (currentNode != null) { if (currentNode.Data >= node1.Data && currentNode.Data <= node2.Data) { // We have found the ancestor node return(currentNode); } else if (currentNode.Data >= node1.Data && currentNode.Data >= node2.Data) { // both the nodes are less than the current node and hence they lie on the left subtree currentNode = currentNode.Left; } else { // both the nodes are on the right subtree currentNode = currentNode.Right; } } return(null); }
public static BinarySearchTreeNode <int> AncestorOfTwoNodesRecursive(BinarySearchTreeNode <int> smaller, BinarySearchTreeNode <int> larger, BinarySearchTreeNode <int> currentNode) { if (smaller == null || larger == null || currentNode == null) { return(null); // Base condition } if (smaller.Data <= currentNode.Data && larger.Data >= currentNode.Data) { // We have found the ancestor node return(currentNode); } else if (smaller.Data <= currentNode.Data && larger.Data <= currentNode.Data) { // both the nodes are less than the current node and hence they lie on the left subtree return(AncestorOfTwoNodesRecursive(smaller, larger, currentNode.Left)); } else { // both the nodes are on the right subtree return(AncestorOfTwoNodesRecursive(smaller, larger, currentNode.Right)); } }
/// <summary> /// Performs the action on all nodes of the subtree in a level-order, right-to-left fashion. /// </summary> private static void LevelOrderRightToLeftVisitor <T>(BinarySearchTreeNode <T> root, Action <BinarySearchTreeNode <T> > action) { if (root == null) { return; } action(root); var queue = new Queue <BinarySearchTreeNode <T> >(); if (root.Right != null) { action(root.Right); queue.Enqueue(root.Right); } if (root.Left != null) { action(root.Left); queue.Enqueue(root.Left); } while (queue.Count > 0) { var curNode = queue.Dequeue(); if (curNode.Right != null) { action(curNode.Right); queue.Enqueue(curNode.Right); } if (curNode.Left != null) { action(curNode.Left); queue.Enqueue(curNode.Left); } } }
// Input nodes are not null and the key at s is less than or equal to that at b. public static BinarySearchTreeNode <int> FindLowestCommonAncestor(BinarySearchTreeNode <int> tree, BinarySearchTreeNode <int> smallKey, BinarySearchTreeNode <int> bigKey) { var p = tree; while (p.Data < smallKey.Data || p.Data > bigKey.Data) { // Keep searching since p is outside of [s, b]. while (p.Data < smallKey.Data) { p = p.Right; // LCA must be in p’s right child. } while (p.Data > bigKey.Data) { p = p.Left; // LCA must be in p’s left child. } } //Now, s.data >= p.data && p.data <- b.data. return(p); }
public BinarySearchTreeNode <T> Search(U targetkey) { BinarySearchTreeNode <T> parent = _rtnd; U pkey; while (parent != null) { pkey = _gkey(parent.Data); if (targetkey.CompareTo(pkey) < 0) { parent = parent.Left; } else if (targetkey.CompareTo(pkey) > 0) { parent = parent.Right; } else { return(parent); } } throw new NotFound(); }
private void ReplaceInParentNode(BinarySearchTreeNode <T> node, BinarySearchTreeNode <T> newNode) { if (node.Parent != null) { if (node.Parent.Left == node) { node.Parent.Left = newNode; } else { node.Parent.Right = newNode; } } else { Root = newNode; } if (newNode != null) { newNode.Parent = node.Parent; } }
private static void RangeLookUpInBinarySearchTreeHelper(BinarySearchTreeNode <int> tree, Interval interval, ICollection <int> result) { if (tree == null) { return; } if (interval.Left <= tree.Data && tree.Data <= interval.Right) { RangeLookUpInBinarySearchTreeHelper(tree.Left, interval, result); result.Add(tree.Data); RangeLookUpInBinarySearchTreeHelper(tree.Right, interval, result); } else if (interval.Left > tree.Data) { RangeLookUpInBinarySearchTreeHelper(tree.Right, interval, result); } else // interval.right >= tree.data { RangeLookUpInBinarySearchTreeHelper(tree.Left, interval, result); } }
private void Remove(BinarySearchTreeNode <T> node, T data) { if (node == null) { throw new ArgumentException($"The node {data} does not exists."); } else if (data.CompareTo(node.Data) < 0) { Remove(node.Left, data); } else if (data.CompareTo(node.Data) > 0) { Remove(node.Right, data); } else { if (node.Left == null && node.Right == null) { ReplaceInParentNode(node, null); Count--; } else if (node.Right == null) { ReplaceInParentNode(node, node.Left); } else if (node.Left == null) { ReplaceInParentNode(node, node.Right); } else { var successor = FindMinimunInSubtree(node.Right); node.Data = successor.Data; Remove(successor, successor.Data); } } }
BinarySearchTreeNode Find(T item) { // binary search BinarySearchTreeNode node = _root; while (node != null) { int result = _comparer.Compare(item, node.Value); if (result == 0) { return(node); } else if (result < 0) { node = node.LesserChild; } else { node = node.GreaterChild; } } return(null); }
public void Add(T data) { var parent = GetParentForNewNode(data); var node = new BinarySearchTreeNode <T> { Data = data, Parent = parent, }; if (parent == null) { Root = node; } else if (data.CompareTo(parent.Data) < 0) { parent.Left = node; } else { parent.Right = node; } Count++; }
public BinarySearchTree(T rootData) { Root = new BinarySearchTreeNode(rootData); Count = 1; }
public void Insert(int n) { head = Insert(head, n); }
public BinarySearchTree() { head = null; }
public void Height_Root() { BinarySearchTreeNode<int> root = new BinarySearchTreeNode<int>(100); Assert.AreEqual<int>(0, root.Height); }
public void Remove(int val, BinarySearchTreeNode Previous) { bool wentLeft = Previous.Value >= Value; if (Value == val) { if (IsLeaf()) { if (wentLeft) { Previous.Left = null; } else { Previous.Right = null; } } else if (Left != null && Right == null) { if (wentLeft) { Previous.Left = Left; } else { Previous.Right = Left; } } else if (Right != null && Left == null) { if (wentLeft) { Previous.Left = Right; } else { Previous.Right = Right; } } else { if (Left.Right != null) { int temp = Left.Right.Value; Left.Remove(temp, this); Value = temp; } else { int temp = Left.Value; Left.Remove(temp, this); Value = temp; } } } else if (val > Value) { Right.Remove(val, this); } else { Left.Remove(val, this); } }
public static void IsRoot(this BinarySearchTreeNode node) { node.Parent.Should().BeNull(); }
public static void IsRightChildOf(this BinarySearchTreeNode child, BinarySearchTreeNode parent) { parent.Right.Should().Be(child); child.Parent.Should().Be(parent); }
/*public BinarySearchTreeNode(T data, BinarySearchTreeNode<T> left = null, BinarySearchTreeNode<T> right = null) * { * Data = data; * Left = left; * Right = right; * //We have to check if the node is BST Node * }*/ public BinarySearchTreeNode(T data) { Data = data; Left = Right = null; }
public void ToString_RootRight() { BinarySearchTreeNode<int> node = new BinarySearchTreeNode<int>(50) { Right = new BinarySearchTreeNode<int>(75), }; Assert.AreEqual<string>("50; Left=null; Right=75", node.ToString()); }
public void InOrderPredecessor_RootLeftRight() { BinarySearchTreeNode<int> rootLeftRight = new BinarySearchTreeNode<int>(50) { Left = new BinarySearchTreeNode<int>(25) { Right = new BinarySearchTreeNode<int>(30) } }; Assert.AreEqual<int>(30, rootLeftRight.InOrderPredecessor.Value); }
public void InOrderSuccessor_RootRightRight() { BinarySearchTreeNode<int> rootRightRight = new BinarySearchTreeNode<int>(50) { Right = new BinarySearchTreeNode<int>(75) { Right = new BinarySearchTreeNode<int>(100) } }; Assert.AreEqual<int>(75, rootRightRight.InOrderSuccessor.Value); }
public void InOrderPredecessor_RootRight() { BinarySearchTreeNode<int> rootRight = new BinarySearchTreeNode<int>(50) { Right = new BinarySearchTreeNode<int>(75) }; Assert.IsNull(rootRight.InOrderPredecessor); }
public void InOrderSuccessor_Leaf() { BinarySearchTreeNode<int> leaf = new BinarySearchTreeNode<int>(50); Assert.IsNull(leaf.InOrderSuccessor); }
public void InOrderSuccessor_RootLeft() { BinarySearchTreeNode<int> rootLeft = new BinarySearchTreeNode<int>(50) { Left = new BinarySearchTreeNode<int>(25) }; Assert.IsNull(rootLeft.InOrderSuccessor); }
public BinarySearchTreeNode(BinarySearchTreeNode <T> left, BinarySearchTreeNode <T> right) { _left = left; _right = right; }
public void Height_RootWithRightChild() { BinarySearchTreeNode<int> root = new BinarySearchTreeNode<int>(100); root.Right = new BinarySearchTreeNode<int>(150); Assert.AreEqual<int>(1, root.Height); }