Program does not need to know anything of the Node implementatio

Author: RedImp1470

BinarySearchTree/BinarySearchTree/BinarySearchTree.cs

@@ -1,47 +1,121 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace BinarySearchTree
 {
+    /// <summary>
+    /// Represents a node in a (binary) tree.
+    /// </summary>
+    /// <typeparam name="T">The payload of the node as generic type.</typeparam>
     public class Node<T>
     {
+        /// <summary>
+        /// The payload of the node.
+        /// </summary>
         public T Value { get; set; }
 
+        /// <summary>
+        /// An item with lower a value than the value of this node will become a LeftNode.
+        /// </summary>
         public Node<T> LeftNode;
+        /// <summary>
+        /// An item with higher a value than the value of this node will become a RightNode.
+        /// </summary>
         public Node<T> RightNode;
 
+        /// <summary>
+        /// Creates a new Node.
+        /// </summary>
+        /// <param name="value">Payload of the new node</param>
         public Node(T value)
         {
             Value = value;
         }
     }
 
-    public class BinarySearchTree<T> where T : IComparable
+
+    /// <summary>
+    /// Data structure that stores items and allows fast lookup, insertion and deletion.
+    /// </summary>
+    /// <typeparam name="T">The type of the trees items.</typeparam>
+    public class BinarySearchTree<T> where T : IComparable<T>
     {
         private Node<T> _globalRoot;
-        public Node<T> InsertNode(Node<T> root, T value)
+        /// <summary>
+        /// Inserts a new node in a existing tree
+        /// </summary>
+        /// <param name="root">The root node of the tree</param>
+        /// <param name="value">Value to be inserted into the tree</param>
+        /// <returns></returns>
+        /*public Node<T> InsertNode(ref Node<T> root, T value)
         {
             if (root == null)
             {
                 root = new Node<T>(value);
-                if(_globalRoot == null)
+                if (_globalRoot == null)
                     _globalRoot = root;
             }
             else
+            {
+                if (value.CompareTo(root.Value) <= 0) 
+                {
+                    root.LeftNode = InsertNode(root.LeftNode, value);
+                }
+                else if (value.CompareTo(root.Value) > 0) //Items with the same value are ignored, use >= to insert them into the three
+                {
+                    root.RightNode = InsertNode(root.RightNode, value);
+                }
+            }
+            return root;
+        }*/
+
+
+        public void InsertNode(T value)
+        {
+            if (_globalRoot == null)
+            {
+                _globalRoot = new Node<T>(value);
+            }
+            else
+            {
+                InsertNode(_globalRoot, value);
+            }
+        }
+
+        private static Node<T> InsertNode(Node<T> root, T value)
+        {
+            if (root == null)
+            {
+                root = new Node<T>(value);
+            }
+            else
             {
                 if (value.CompareTo(root.Value) <= 0)
                 {
                     root.LeftNode = InsertNode(root.LeftNode, value);
                 }
-                else if (value.CompareTo(root.Value) >= 0)
+                else if (value.CompareTo(root.Value) > 0)//Items with the same value are ignored, use >= to insert them into the three
                 {
                     root.RightNode = InsertNode(root.RightNode, value);
                 }
             }
             return root;
         }
 
-        public IEnumerable<T> PreorderTraverseTree(Node<T> root)
+        /// <summary>
+        /// Preorder traversal of the tree. Visites the root, then visits the left sub-tree, after that it visits the right sub-tree.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<T> PreorderTraverseTree()
+        {
+            if (_globalRoot == null) yield break;
+
+            foreach (var node in PreorderTraverseTree(_globalRoot))
+                yield return node;
+        }
+
+        private static IEnumerable<T> PreorderTraverseTree(Node<T> root)
         {
             if (root == null) yield break;
             yield return root.Value;
@@ -56,7 +130,43 @@ public IEnumerable<T> PreorderTraverseTree(Node<T> root)
             }
         }
 
-        public void DeleteNode(ref Node<T> root, T value)
+        /// <summary>
+        /// Inorder traversal of the tree.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<T> InOrderTraverseTree()
+        {
+            if (_globalRoot == null) yield break;
+
+            foreach (var node in InOrderTraverseTree(_globalRoot))
+                yield return node;
+        }
+
+        private static IEnumerable<T> InOrderTraverseTree(Node<T> root)
+        {
+            if (root == null) yield break;
+            foreach (var v in InOrderTraverseTree(root.LeftNode))
+            {
+                yield return v;
+            }
+            yield return root.Value;
+            foreach (var v in InOrderTraverseTree(root.RightNode))
+            {
+                yield return v;
+            }
+        }
+
+        /// <summary>
+        /// Deletes a node from the tree.
+        /// </summary>
+        /// <param name="value">Value of the node which is to be deleted.</param>
+        public void DeleteNode(T value)
+        {
+            if (_globalRoot == null) return;
+            DeleteNode(ref _globalRoot, value);
+        }
+
+        private void DeleteNode(ref Node<T> root, T value)
         {
             if (root == null) return;
             if (root.Value.Equals(value))
@@ -69,14 +179,46 @@ public void DeleteNode(ref Node<T> root, T value)
             }
         }
 
-        private Node<T> Delete(ref Node<T> root)
+        /// <summary>
+        /// Traverses the tree to find and return a Node with a certain value.
+        /// </summary>
+        /// <param name="value">The value to search for</param>
+        /// <returns></returns>
+        public T FindNode(T value)
+        {
+            var res = FindNode(_globalRoot, value);
+
+            return res.Value;
+        }
+
+        private static Node<T> FindNode(Node<T> root, T value)
+        {
+            Node<T> res = null;
+            if (root.LeftNode != null)
+                res = FindNode(root.LeftNode, value);
+
+            if (value.CompareTo(root.Value) == 0)
+                return root;
+
+            if (res == null && root.RightNode != null)
+                res = FindNode(root.RightNode, value);
+
+            return res;
+        }
+
+        /// <summary>
+        /// Only use with custom implementations of DeleteNode!
+        /// </summary>
+        /// <param name="root">The root node of the tree.</param>
+        /// <returns></returns>
+        public Node<T> Delete(ref Node<T> root)
         {
             var tempValue = default(T);
 
-            if (_globalRoot == root)
+            if (_globalRoot == root && root.LeftNode == null && root.RightNode == null)
             {
-                //Deletion of root element is not allowed;
-                return root;
+                //Deletion of root element is allowed  - to for forbid it, return root
+                return null;
             }
             if (root.LeftNode == null && root.RightNode == null)
             {
@@ -111,5 +253,29 @@ private static void Replace(ref Node<T> root, ref T newValue)
                 Replace(ref root.LeftNode, ref newValue);
             }
         }
+
+        public BinarySearchTree<T> BalancedTree()
+        {
+            var balanced = new BinarySearchTree<T>();
+            var inorder = InOrderTraverseTree().ToArray();
+
+            balanced._globalRoot = BalanceTree(inorder, 0, inorder.Length - 1);
+
+            return balanced;
+        }
+
+        private static Node<T> BalanceTree(IReadOnlyList<T> inorder, int startIndex, int endIndex)
+        {
+            if (startIndex > endIndex) return null;
+
+            var middIndex = (startIndex + endIndex) / 2;
+
+            var root = new Node<T>(inorder[middIndex]);
+
+            root.LeftNode = BalanceTree(inorder, startIndex, middIndex - 1);
+            root.RightNode = BalanceTree(inorder, middIndex + 1, endIndex);
+
+            return root;
+        }
     }
 }

BinarySearchTree/BinarySearchTree/Program.cs

@@ -24,27 +24,48 @@ static void Main(string[] args)
 
             foreach (var r in rnd)
             {
-                root = tree.InsertNode(root, r);
+                tree.InsertNode(r);
             }
 
             Console.WriteLine("input array: ");
             Console.WriteLine(string.Join(",", rnd));
             Console.ReadLine();
 
-            var values = tree.PreorderTraverseTree(root).ToList();
+            var values = tree.PreorderTraverseTree().ToList();
             Console.WriteLine("the trees preorder traversal: ");
             Console.WriteLine(string.Join(",", values));
             Console.ReadLine();
 
+            var vals = tree.InOrderTraverseTree().ToList();
+            Console.WriteLine("the trees inorder traversal: ");
+            Console.WriteLine(string.Join(",", vals));
+            Console.ReadLine();
+
             var rndItem = rnd[rndNo.Next(0, rnd.Length)];
             Console.WriteLine(rndItem + " will be deleted from tree");
             Console.ReadLine();
-            tree.DeleteNode(ref root, rndItem);
+            tree.DeleteNode(rndItem);
 
-            var restTree = tree.PreorderTraverseTree(root).ToList();
+            var restTree = tree.PreorderTraverseTree().ToList();
             Console.WriteLine("tree after deletion: ");
             Console.WriteLine(string.Join(",", restTree));
             Console.ReadLine();
+
+            var treeContent = tree.PreorderTraverseTree().ToList();
+            var rndItem1 = treeContent[2];
+            Console.WriteLine("try to find: " + rndItem1);
+            var test = tree.FindNode(rndItem1);
+            Console.WriteLine("Found: "+test);
+            Console.ReadLine();
+
+            Console.WriteLine("Balancing tree now");
+            var balancedTree = tree.BalancedTree();
+
+            var balancedPreOrder = balancedTree.PreorderTraverseTree().ToList();
+            Console.WriteLine("preorder traversal of balanced tree: ");
+            Console.WriteLine(string.Join(",", balancedPreOrder));
+            Console.ReadLine();
+
         }
     }
 }