using : “); succ = int.Parse(Console.ReadLine()); Console.WriteLine(” Successor of

using System;using System.Collections.Generic;using System.Linq;using System.Text.RegularExpressions;namespace Rextester{    public class Program    {        public static void Main(string args)        {            BinarySearchTree bst = new BinarySearchTree();            int a,add;            Console.WriteLine(“Enter the number range you want to add in bst : “);            a = int.Parse(Console.ReadLine());            for (int i = 0; i < a;i++ )            {                add = int.Parse(Console.ReadLine());                bst.Add(add);            }                           bst.Inorder();            Console.WriteLine(" Enter the number you want to delete : ");            int d;            d = int.Parse(Console.ReadLine());            bst.Delete(d);            Console.WriteLine("Inorder traversal: ");            bst.Inorder();            Console.WriteLine(" Post order traversal: ");            bst.Postorder();            Console.WriteLine(" Pre order traversal: ");            bst.Preorder();            int succ;            Console.WriteLine(" Enter the successor you want to find of : ");            succ = int.Parse(Console.ReadLine());            Console.WriteLine(" Successor of {0} is : {1} ", succ, bst.Successor(succ).value);            int find;            Console.WriteLine(" Enter the number you want to find: ");            find = int.Parse(Console.ReadLine());            Console.WriteLine(" Seaching : => ” + ((bst.Search(find) != null) ? “Present” : “Not Present”));            Console.ReadLine();        }    }    public class BinarySearchTree    {        node root;        public BinarySearchTree()        {            root = new node();        }        public void Add(int v)        {            insert(root, v);        }        public void Inorder()        {            inorder(root);        }        public void Postorder()        {            postorder(root);        }        public void Preorder()        {            preorder(root);        }        public bool Delete(int v)        {            return (delete(root, v) == null);        }        public node Successor(int v)        {            return inOrderSuccessor(Search(v));        }        public node Search(int v)        {            return search(root, v);        }        private node delete(node root, int v)        {            if (root == null) return null;            // If the key to be deleted is smaller than the root’s key,            // then it lies in left subtree            if (v < root.value)                root.left = delete(root.left, v);            // If the key to be deleted is greater than the root's key,            // then it lies in right subtree            else if (v > root.value)                root.right = delete(root.right, v);            else            {                // node with only one child or no child                if (root.left == null)                {                    return root.right;                }                else if (root.right == null)                {                    return root.left;                }                // node with two children: Get the inorder successor (smallest                // in the right subtree)                node temp = minValueNode(root.right);                // Copy the inorder successor’s content to this node                root.value = temp.value;                // Delete the inorder successor                root.right = delete(root.right, temp.value);            }            return root;        }        private node minValueNode(node root)        {            node current = root;            /* loop down to find the leftmost leaf */            while (current.left != null)                current = current.left;            return current;        }        private node inOrderSuccessor(node ne)        {            if (ne == null)                return null;            // step 1 : If right subtree of node is not NULL, then succ lies in right subtree.            if (ne.right != null)                return minValueNode(ne.right);            // step 2 : If right sbtree of node is NULL, then succ is one of the ancestors.            node pare = ne.parent;            while (pare != null && ne == pare.right)            {                ne = pare;                pare = pare.parent;            }            return pare;        }        //———– RECURSIVE METHOD ONLY USED BY CLASS THERFORE ARE PRIVATE ————-//        private void inorder(node root)        {            if (root != null)            {                inorder(root.left);                Console.Write(”
< {0} >“, root.value);                inorder(root.right);            }        }        private void postorder(node root)        {            if (root != null)            {                inorder(root.left);                inorder(root.right);                Console.Write(”
< {0} >“, root.value);            }        }        private void preorder(node root)        {            if (root != null)            {                Console.Write(”
< {0} >“, root.value);                inorder(root.left);                inorder(root.right);            }        }        private node insert(node root, int v)        {            if (root == null)            {                root = new node(v);            }            else            {                node temp;                if (v < root.value)                {                    temp = insert(root.left, v);                    root.left = temp;                    temp.parent = root;                }                else                {                    temp = insert(root.right, v);                    root.right = temp;                    temp.parent = root;                }            }            return root;        }        private node search(node root, int v)        {            // Base Cases: root is null or key is present at root            if (root == null || root.value == v)                return root;            // Key is greater than root's key            if (root.value < v)                return search(root.right, v);            // Key is smaller than root's key            return search(root.left, v);        }        //----------- END RECURSIVE METHOD -------------//                public class node        {            public node left;            public node right;            public node parent;            public int value;            public node()            {                left = null;                right = null;                parent = null;            }            public node(int va)            {                value = va;                left = null;                right = null;                parent = null;            }        }    }}

x

Hi!
I'm Dianna!

Would you like to get a custom essay? How about receiving a customized one?

Check it out