public void FindInorderPredecessorAndSuccessorOfKey(BinarySearchTreeNodeSM root, int i, ref BinarySearchTreeNodeSM pred, ref BinarySearchTreeNodeSM succ) { if (root == null) { return; } if (root.Data == i) { BinarySearchTreeNodeSM dummy = root.LeftChild; while (dummy.RightChild != null) { dummy = dummy.RightChild; } pred = dummy; if (root.RightChild != null) { dummy = dummy.LeftChild; } succ = dummy; return; } if (root.Data > i) { succ = root; FindInorderPredecessorAndSuccessorOfKey(root.LeftChild, i, ref pred, ref succ); } if (root.Data < i) { pred = root; FindInorderPredecessorAndSuccessorOfKey(root.RightChild, i, ref pred, ref succ); } }
internal int FindCeilSm(BinarySearchTreeNodeSM root, BinarySearchTreeNodeSM temp, int key) { if (root == null) { if (temp != null) { return(temp.Data); } else { return(-1); } } if (root.Data == key) { return(root.Data); } if (root.Data > key) { temp = root; return(FindCeilSm(root.LeftChild, temp, key)); } if (root.Data < key) { return(FindCeilSm(root.RightChild, temp, key)); } return(-1); }
private BinarySearchTreeNodeSM InOrderSuccessorNode(BinarySearchTreeNodeSM node, BinarySearchTreeNodeSM successorOf) { if (successorOf.RightChild != null) { BinarySearchTreeNodeSM temp = successorOf.RightChild; while (temp.LeftChild != null) { temp = temp.LeftChild; } return(temp); } BinarySearchTreeNodeSM temp2 = null; while (node != null) { if (node.Data < successorOf.Data) { node = node.RightChild; } else if (node.Data > successorOf.Data) { temp2 = node; node = node.LeftChild; } else { break; } } return(temp2); }
public int FindTheMinValue(BinarySearchTreeNodeSM root) { if (root.LeftChild == null) { return(root.Data); } return(FindTheMinValue(root.LeftChild)); }
private int MaxNodeValue(BinarySearchTreeNodeSM nodeLeftChild) { while (nodeLeftChild.RightChild != null) { nodeLeftChild = nodeLeftChild.RightChild; } return(nodeLeftChild.Data); }
public void InOrderTransversal(BinarySearchTreeNodeSM root) { if (root == null) { return; } InOrderTransversal(root.LeftChild); Console.WriteLine(root.Data); InOrderTransversal(root.RightChild); }
public BinarySearchTreeNodeSM InOrderSuccessor(BinarySearchTreeNodeSM node, int i) { if (node == null) { return(null); } BinarySearchTreeNodeSM successorOf = FindTheGivenData(node, i); BinarySearchTreeNodeSM successorNode = InOrderSuccessorNode(node, successorOf); return(successorNode); }
public void CorrectSwappedNodes(BinarySearchTreeNodeSM root) { BinarySearchTreeNodeSM first = null, prev = null, last = null, middle = null; CorrectSwappedNodesUtil(root, ref first, ref middle, ref last, ref prev); if (first != null && last != null) { swap(ref first.Data, ref last.Data); } else if (first != null && middle != null) { swap(ref first.Data, ref middle.Data); } }
public bool CheckIfBstOrNot(BinarySearchTreeNodeSM node) { if (node == null) { return(true); } if (node.LeftChild != null && MaxNodeValue(node.LeftChild) > node.Data) { return(false); } if (node.RightChild != null && MinNodeValue(node.RightChild) < node.Data) { return(false); } return(CheckIfBstOrNot(node.LeftChild) && CheckIfBstOrNot(node.RightChild)); }
public BinarySearchTreeNodeSM GetLeastCommonAncestor(BinarySearchTreeNodeSM node, int a, int b) { if (node == null) { return(null); } if (node.Data >= a && node.Data <= b) { return(node); } if (node.Data > a && node.Data > b) { return(GetLeastCommonAncestor(node.LeftChild, a, b)); } return(GetLeastCommonAncestor(node.RightChild, a, b)); }
public BinarySearchTreeNodeSM AddNode(BinarySearchTreeNodeSM node, int data) { if (node == null) { node = new BinarySearchTreeNodeSM(data); return(node); } if (node.Data < data) { node.RightChild = AddNode(node.RightChild, data); } else { node.LeftChild = AddNode(node.LeftChild, data); } return(node); }
public BinarySearchTreeNodeSM FindTheGivenData(BinarySearchTreeNodeSM node, int d) { if (node == null) { return(null); } if (node.Data == d) { return(node); } if (node.Data > d) { return(FindTheGivenData(node.LeftChild, d)); } else { return(FindTheGivenData(node.RightChild, d)); } }
private void CorrectSwappedNodesUtil(BinarySearchTreeNodeSM root, ref BinarySearchTreeNodeSM first, ref BinarySearchTreeNodeSM middle, ref BinarySearchTreeNodeSM last, ref BinarySearchTreeNodeSM prev) { if (root == null) { return; } CorrectSwappedNodesUtil(root.LeftChild, ref first, ref middle, ref last, ref prev); if (prev != null && root.Data < prev.Data) { if (first == null) { first = prev; middle = root; } else { last = root; } } prev = root; CorrectSwappedNodesUtil(root.RightChild, ref first, ref middle, ref last, ref prev); }
internal void DeleteNodeWithData(BinarySearchTreeNodeSM root, int v) { }