private void Print(Binarynode p, int padding) { if (p != null) { if (p.right != null) { Print(p.right, padding + 4); } if (padding > 0) { Console.Write(" ".PadLeft(padding)); } if (p.right != null) { Console.Write("/\n"); Console.Write(" ".PadLeft(padding)); } Console.Write(p.item.ToString() + "\n "); if (p.left != null) { Console.Write(" ".PadLeft(padding) + "\\\n"); Print(p.left, padding + 4); } } }
/// <summary> /// Add a symbol to the tree if it's a new one. Returns reference to the new /// node if a new node inserted, else returns null to indicate node already present. /// 1. Starting at the root of the tree, search the binary tree comparing the new key to the key in the current node. /// If the new key is less than the current node, search the left subtree. If the new key is greater than the current node, search the right subtree. /// 2. When there is no left (or right) child to search, we have found the position in the tree where the new node should be installed. /// 3. To add a node to the tree, create a new TreeNode object and insert the object at the point discovered in the previous step. /// </summary> /// <param name="Node">Name of node to add to tree</param> /// <param name="Item">Value of node</param> /// <returns> Returns reference to the new node is the node was inserted. /// Returns a default sort order comparer for the type specified by the generic argument.</returns> private bool Add_Sub(Binarynode Node, int Item) { if (_comparer.Compare(Node.item, Item) < 0) { if (Node.right == null) { Node.right = new Binarynode(Item); _count++; return(true); } else { return(Add_Sub(Node.right, Item)); } } else if (_comparer.Compare(Node.item, Item) > 0) { if (Node.left == null) { Node.left = new Binarynode(Item); _count++; return(true); } else { return(Add_Sub(Node.left, Item)); } } else { return(false); } }
/// <summary> /// create constructor for that /// Initially root is equal to null & ofcourse count is also null /// & allocate space for array /// then for loop for count the node one by one and sorted data. /// </summary> /// <param name="size"></param> public BinarySearch(int size) { _root = null; _count = 0; data = new int[size]; for (int i = 0; i < size; i++) { data[i] = _count; } Array.Sort(data); }
/// <summary> /// Add method: /// if the root is null then create a new root and increase by one ans so on and if it is not return the add_sub method /// </summary> /// <param name="Item">passing item to be current node</param> /// <returns>Sucessfull</returns> public bool Add(int Item) { if (_root == null) { _root = new Binarynode(Item); _count++; return(true); } else { return(Add_Sub(_root, Item)); } }
/// <summary> /// Find the next ordinal node starting at node startNode. /// Due to the structure of a binary search tree, the /// successor node is simply the left most node on the right branch. /// </summary> /// <param name="value">Name key to use for searching</param> /// <returns>Returns a reference to the node if successful, else null</returns> public int Search(int value) { int found = -1; Binarynode localRoot = _root; found = find(value, "left", localRoot); if (found == -1) { localRoot = _root; found = find(value, "right", localRoot); } if (found == -1) { Console.WriteLine("Item {0} not found in tree.", value); } return(found); }
/// <summary> /// /// </summary> /// <param name="value"></param> /// <param name="findSide"></param> /// <param name="localRoot"></param> /// <returns></returns> private int find(int value, string findSide, Binarynode localRoot) { int found = -1; //Binarynode localRoot = _root; while (localRoot != null) { if (value.Equals(localRoot.item)) { found = localRoot.item; break; } else if (localRoot.left != null && value.Equals(localRoot.left.item)) { found = localRoot.left.item; break; } else if (localRoot.right != null && value.Equals(localRoot.right.item)) { found = localRoot.right.item; break; } if (findSide.Equals("left")) { localRoot = localRoot.left; } else if (findSide.Equals("right")) { localRoot = localRoot.right; } } if (found != -1) { Console.WriteLine("Item found in tree = {0} on side = {1}", found, findSide); return(found); } return(found); }
/// <summary> /// Constructor to create a single node item as like root /// </summary> /// <param name="item">passing item parameters</param> public Binarynode(int item) { this.item = item; left = null; right = null; }