Merge pull request 'Update Readme' (#14) from development into master

Reviewed-on: luke-else/DataStructures#14

C#/Datastructures/BinaryTree/Tree.cs

@@ -0,0 +1,286 @@
+using C_.Datastructures.LinkedList;
+using C_.Datastructures.Stack;
+using C_.Datastructures.Queue;
+using System;
+
+namespace C_.Datastructures.BinaryTree
+{
+    internal class Tree<T> where T:IComparable
+    {
+        public TreeNode<T>? Root { get; set; }
+        public int Count { get; set; }
+
+        public static Tree<T> Create(){
+            //Create a new Tree with no Head
+            return new Tree<T>{
+                Root = null,
+                Count = 0
+            };
+        }
+
+        public static Tree<T> Create(T value){
+            //Create a new Tree with Head
+            return new Tree<T>{
+                Root = TreeNode<T>.Create(value)
+            };
+        }
+
+        public void Add(T value)
+        {//Add item to the correct position in the tree (Input cannot be null)
+            Count++;
+
+            if (Root == default)
+            {//If new node should become the root
+                Root = TreeNode<T>.Create(value);
+                return;
+            }
+
+            //Find position to insert
+            TreeNode<T> node = Root;
+            node = Descend(value, node)!;
+
+            if (value.CompareTo(node.Value) < 0)
+            {//Insert to left
+                node.Left = TreeNode<T>.Create(value);
+                return;
+            }
+            //Insert to right
+            node.Right = TreeNode<T>.Create(value);
+            return;
+        }
+
+        public bool Delete(T value)
+        {
+            //Check if root of tree is null
+            if (Count == 0)
+                return false;
+            
+            //Check if the only value is the root
+            if (Count == 1)
+            {
+                if (Root!.Value!.Equals(value))
+                {//If the only item is the one we are trying to delete
+                    Count = 0;
+                    Root = default;
+                    return true;
+                }
+                return false;
+            }
+
+            //Stack to store the items leading up to and including the one we are trying to delete    
+            Stack<TreeNode<T>>? deletionStack;
+
+            //Search for item being deleted + Parents
+            deletionStack = Find(value);
+
+            if (deletionStack == default)
+                return false; //Item was not found
+
+            //Delete Item (replace) and replace pointers to retain integrity of tree
+
+            TreeNode<T>? node = deletionStack.Pop();
+
+            //stack to store the items leading up to the value that we will use to replace the node
+            Stack<TreeNode<T>>? replacementStack = Min(node!.Right);
+            
+            if (replacementStack == default)
+            {//Nothing to the right of the value we are deleting
+                if (deletionStack.Peek() != default)
+                {//Parent adopts left hand side of node if present
+                    deletionStack.Pop()!.Left = node.Left;
+                }
+
+                if (node.Left != default)
+                {//Node adopts left value if no lower value to the right
+                    node.Value = node.Left!.Value;
+                    node.Left = node.Left.Left;
+                }
+            }
+            else
+            {//Replace the value + reorder nodes
+                node.Value = replacementStack.Peek()!.Value;
+                TreeNode<T>? replacementNode = replacementStack.Pop();
+
+                switch (replacementStack.GetCount())
+                {//Determine what to do based on number of items in replacement stack
+                    case 1:
+                        node.Right = replacementNode!.Right;
+                        break;
+                    case >=2:
+                        replacementStack.Peek()!.Left = replacementNode!.Right;
+                        break;
+                    default:
+                        break;
+                }
+            }
+            Count--;
+            return true;
+        }
+
+        public LinkedList<T>? Traverse(TraversalType traversalType)
+        {
+            if (Root == default)
+                return default;
+
+            LinkedList<T> list = LinkedList<T>.Create();
+
+            switch (traversalType)
+            {//Select which type of traversal to do
+                case TraversalType.Inorder:
+                    Inorder(list, Root);
+                    break;
+                case TraversalType.Preorder:
+                    Preorder(list, Root);
+                    break;
+                case TraversalType.Postorder:
+                    Postorder(list, Root);
+                    break;
+                case TraversalType.Breadth:
+                    Queue<TreeNode<T>> queue = Queue<TreeNode<T>>.Create();
+                    BreadthFirst(list, queue, Root);
+                    break;
+                default:
+                    return default;
+            }
+
+            return list;
+        }
+        private void Inorder(LinkedList<T> list, TreeNode<T> node)
+        {//Inorder Traversal
+            if (node.Left != default)
+                Inorder(list, node.Left);
+
+            list.Append(node.Value);
+
+            if (node.Right != default)
+                Inorder(list, node.Right);
+        }
+
+        private void Preorder(LinkedList<T> list, TreeNode<T> node)
+        {//Preorder Traversal
+            list.Append(node.Value);
+            
+            if (node.Left != default)
+                Preorder(list, node.Left);
+
+            if (node.Right != default)
+                Preorder(list, node.Right);
+        }
+
+        private void Postorder(LinkedList<T> list, TreeNode<T> node)
+        {//Postorder Traversal
+            if (node.Left != default)
+                Postorder(list, node.Left);
+
+            if (node.Right != default)
+                Postorder(list, node.Right);
+
+            list.Append(node.Value);
+        }
+
+        private void BreadthFirst(LinkedList<T> list, Queue<TreeNode<T>> queue, TreeNode<T> node)
+        {//Breadth First Traversal
+            list.Append(node.Value);
+
+            if (node.Left != default)
+                queue.Push(node.Left);
+
+            if (node.Right != default)
+                queue.Push(node.Right);
+
+            //Only continue to traverse if there are no mode nodes to process
+            if (queue.Peek() != default)
+                BreadthFirst(list, queue, queue.Pop()!);
+        }
+
+
+
+
+        private static TreeNode<T>? GetNext(T value, TreeNode<T>? node)
+        {//T is comparable so use methods to determine which way to traverse
+            if(node == default)
+                return default;
+
+            if (value.CompareTo(node.Value) < 0)
+            {//Traverse Left
+                return node.Left;
+            }
+            //Traverse Right
+            return node.Right;
+        }
+
+        private Stack<TreeNode<T>>? Find(T value)
+        {//Return true if the item can be found within the tree
+            if (Root == default || Root.Value!.Equals(default))
+                return default;
+
+            Stack<TreeNode<T>>? stack = Stack<TreeNode<T>>.Create(Root);
+
+            while (stack.Peek() != default)
+            {
+                //Compare value at node to see if we are looking for the root item
+                if (stack.Peek()!.Value!.Equals(value))
+                    return stack;
+
+                stack.Push(GetNext(value, stack.Peek()));
+            }
+            return default;
+        }
+
+        private static Stack<TreeNode<T>>? Min(TreeNode<T>? node)
+        {//Returns a Stack with the value on top being the minimum of the subtree
+            
+            if(node == default)
+                return default;
+
+            //Stack to store and be able to get the parent values
+            Stack<TreeNode<T>> stack = Stack<TreeNode<T>>.Create(node);
+
+            while(true){
+                if (stack.Peek()!.Left == default)
+                    return stack;
+
+                stack.Push(stack.Peek()!.Left);
+            }
+        }
+
+        private static Stack<TreeNode<T>>? Max(TreeNode<T>? node)
+        {///Returns a Stack with the value on top being the maximum of the subtree
+            if(node == default)
+                return default;
+
+            //Stack to store and be able to get the parent values
+            Stack<TreeNode<T>> stack = Stack<TreeNode<T>>.Create(node);
+
+            while(true){
+                if (stack.Peek()!.Right == default)
+                    return stack;
+
+                stack.Push(stack.Peek()!.Right);
+            }
+        }
+
+        private TreeNode<T>? Descend(T value, TreeNode<T>? current)
+        {//Keep trying to determine whether to go left or right until null node is found that can be appended to
+            if (current == default)
+                return default;
+
+            TreeNode<T>? node;
+
+            node = Descend(value, GetNext(value, current));
+            if (node == null)
+            {
+                return current;
+            }
+            return node;
+        }
+    }
+
+    public enum TraversalType
+    {//Enum to allow for Traversal selection
+        Inorder,
+        Preorder,
+        Postorder,
+        Breadth
+    }
+}

C#/Datastructures/BinaryTree/TreeNode.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using C_.Datastructures.Generic;
+
+namespace C_.Datastructures.BinaryTree
+{
+    internal class TreeNode<T> : DirectedNode<T, TreeNode<T>>
+    {
+        //All properties inherited from base class
+        public static TreeNode<T> Create(T value){
+            //Create a new node without any children
+            return new TreeNode<T>{
+                Value = value
+            };
+        }
+        
+        public static TreeNode<T> Create(T value, TreeNode<T>? left, TreeNode<T>? right){
+            //Create a new node with the option of having children
+            return new TreeNode<T>{
+                Value = value,
+                Left = left,
+                Right = right
+            };
+        }
+    }
+}

C#/Datastructures/DoublyLinkedList/DoublyLinkedList.cs

@@ -1,10 +1,4 @@
-using System;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using C_.Datastructures.Nodes;
-
-namespace C_.Datastructures
+namespace C_.Datastructures.DoublyLinkedList
 {
     public class DoublyLinkedList<T>
     {
@@ -18,7 +12,7 @@ namespace C_.Datastructures
             return new DoublyLinkedList<T>();
         }
 
-        public static DoublyLinkedList<T> Create(T value)
+        public static DoublyLinkedList<T> Create(T? value)
         {
             //Create a new Class with a single item
             return new DoublyLinkedList<T>()
@@ -28,11 +22,10 @@ namespace C_.Datastructures
             };
         }
 
-
         public static DoublyLinkedList<T> Create(DoublyLinkedList<T> list1, DoublyLinkedList<T> list2)
         {
             //Create a new list from 2 separate lists
-            
+
             DoublyLinkedList<T> list;
 
             list = list1;
@@ -74,7 +67,7 @@ namespace C_.Datastructures
                 node!.Value = value;
             }
         }
-        public void Append(T value)
+        public void Append(T? value)
         {
             Count++;
 
@@ -91,7 +84,7 @@ namespace C_.Datastructures
             Tail = Tail.Next;
         }
 
-        public void Insert(int index, T value)
+        public void Insert(int index, T? value)
         {
             Count++;
             if (index > Count || index < 0) throw new System.Exception("Error! Index outside of Bounds");
@@ -118,7 +111,7 @@ namespace C_.Datastructures
             node!.Next = DoublyLinkedListNode<T>.Create(value, node.Next, node);
 
             //Create backlink in the list
-            if(node.Next.Next != default)
+            if (node.Next.Next != default)
                 node.Next.Next.Prev = node.Next;
         }
 
@@ -131,7 +124,7 @@ namespace C_.Datastructures
             if (index == 0 && Head != default)
             {
                 Head = Head!.Next;
-                if(Head != default) 
+                if (Head != default)
                     Head.Prev = default;
                 return;
             }
@@ -141,7 +134,7 @@ namespace C_.Datastructures
             {
                 Tail = Tail!.Prev;
 
-                if(Tail != default) 
+                if (Tail != default)
                     Tail.Next = default;
                 return;
             }
@@ -153,10 +146,14 @@ namespace C_.Datastructures
             //Connect item after to the the item before the node we are deleting
             if (node.Next != default)
             {
-                node.Next.Prev = node;                
+                node.Next.Prev = node;
             }
         }
 
+        public int GetCount()
+        {//Return the number of items in the list
+            return Count;
+        }
 
         private DoublyLinkedListNode<T>? Traverse()
         {
@@ -170,7 +167,7 @@ namespace C_.Datastructures
             int direction = 1;
             DoublyLinkedListNode<T>? node = Head;
 
-            if (i > (Count/2))
+            if (i > (Count / 2))
             {
                 //reverse direction of search
                 direction = -1;

C#/Datastructures/DoublyLinkedList/DoublyLinkedListNode.cs

@@ -1,14 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using C_.Datastructures.Generic;
 
-namespace C_.Datastructures.Nodes
+namespace C_.Datastructures.DoublyLinkedList
 {
-    internal class DoublyLinkedListNode<T> : Node<T, DoublyLinkedListNode<T>>
+    internal class DoublyLinkedListNode<T> : UndirectedNode<T, DoublyLinkedListNode<T>>
     {//Inherits from Node
-        public DoublyLinkedListNode<T>? Prev { get; set; } = default;
+        internal DoublyLinkedListNode<T>? Prev { get; set; } = default;
 
         public static DoublyLinkedListNode<T> Create(T? value, DoublyLinkedListNode<T>? next, DoublyLinkedListNode<T>? prev)
         {

C#/Datastructures/Generic/DirectedNode.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace C_.Datastructures.Generic
+{
+    abstract internal class DirectedNode<T, NodeType>
+    {
+        public T? Value { get; set; } = default;
+        internal NodeType? Left { get; set; } = default;
+        internal NodeType? Right { get; set; } = default;
+    }
+}

C#/Datastructures/Generic/UndirectedNode.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace C_.Datastructures.Generic
+{
+    abstract internal class UndirectedNode<T, NodeType>
+    {//Generic Node type that every other type inherits from
+        public T? Value { get; set; } = default;
+        internal NodeType? Next { get; set; } = default;
+    }
+}

C#/Datastructures/LinkedList/LinkedList.cs

@@ -1,29 +1,31 @@
-using C_.Datastructures.Nodes;
-
-namespace C_.Datastructures
+namespace C_.Datastructures.LinkedList
 {
     public class LinkedList<T>
     {
         internal LinkedListNode<T>? Head { get; set; } = default;
         private int Count { get; set; } = 0;
 
-        public static LinkedList<T> Create(){
+        public static LinkedList<T> Create()
+        {
             //Create a new empty list
             return new LinkedList<T>();
         }
 
-        public static LinkedList<T> Create(T value){
+        public static LinkedList<T> Create(T? value)
+        {
             //Create a new Class with a single item
-            return new LinkedList<T>(){
+            return new LinkedList<T>()
+            {
                 Head = LinkedListNode<T>.Create(value, null),
                 Count = 1
             };
         }
 
-        public static LinkedList<T> Create(LinkedList<T> list1, LinkedList<T> list2){
+        public static LinkedList<T> Create(LinkedList<T> list1, LinkedList<T> list2)
+        {
             //Append a previous list to a new List
             LinkedList<T> list;
-            
+
             list = list1;
             if (list == null || list.Count == 0) return list2;
 
@@ -52,7 +54,7 @@ namespace C_.Datastructures
             set
             {
                 //Check Range
-                if (i >= Count || i < 0 ) throw new System.Exception("Error! Index out of Bounds");
+                if (i >= Count || i < 0) throw new System.Exception("Error! Index out of Bounds");
 
                 //Change Value
                 LinkedListNode<T>? node = Traverse(i);
@@ -60,13 +62,14 @@ namespace C_.Datastructures
             }
         }
 
-        public void Append(T value){
+        public void Append(T? value)
+        {
             //Create new node
             Count++;
             LinkedListNode<T> newItem = LinkedListNode<T>.Create(value, default);
 
             //Set head to new item if list is empty
-            if (Head == null) 
+            if (Head == null)
             {
                 Head = newItem;
                 return;
@@ -83,7 +86,7 @@ namespace C_.Datastructures
             end!.Next = newItem;
         }
 
-        public void Insert(int index, T value)
+        public void Insert(int index, T? value)
         {
             Count++;
             if (index > Count || index < 0) throw new System.Exception("Error! Index outside of Bounds");
@@ -119,11 +122,17 @@ namespace C_.Datastructures
             node!.Next = node.Next!.Next;
         }
 
-        private LinkedListNode<T>? Traverse(){
+        public int GetCount()
+        {//Return the number of items in the list
+            return Count;
+        }
+
+        private LinkedListNode<T>? Traverse()
+        {
             //Start at Head of list
             LinkedListNode<T>? node = Head;
             if (node != null)
-            {   
+            {
                 //continue to end of list
                 while (node!.Next != default)
                 {
@@ -133,20 +142,6 @@ namespace C_.Datastructures
             return node;
         }
 
-        //private static LinkedListNode<T>? Traverse(LinkedListNode<T> start){
-        //    //Start at given point in list
-        //    LinkedListNode<T>? node = start;
-        //    if (node != null)
-        //    {
-        //        //Continue to end of list
-        //        while (node!.Next != default)
-        //        {
-        //            node = (LinkedListNode<T>)node.Next;
-        //        }
-        //    }
-        //    return node;
-        //}
-
         private LinkedListNode<T>? Traverse(int i)
         {
             //Start at given point in list

C#/Datastructures/LinkedList/LinkedListNode.cs

@@ -1,12 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using C_.Datastructures.Generic;
 
-namespace C_.Datastructures.Nodes 
+namespace C_.Datastructures.LinkedList
 {
-    internal class LinkedListNode<T> : Node<T, LinkedListNode<T>>
+    internal class LinkedListNode<T> : UndirectedNode<T, LinkedListNode<T>>
     {//Inherits from Node
         public static LinkedListNode<T> Create(T? value, LinkedListNode<T>? next)
         {

C#/Datastructures/Nodes/Node.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace C_.Datastructures.Nodes
-{
-    internal class Node<T, NodeType>
-    {//Generic Node type that every other type inherits from
-        public T? Value { get; set; } = default;
-        public NodeType? Next { get; set; } = default;
-    }
-}

C#/Datastructures/Queue/Queue.cs

@@ -0,0 +1,75 @@
+namespace C_.Datastructures.Queue
+{
+    internal class Queue<T>
+    {
+        internal QueueNode<T>? Head { get; set; }
+        internal QueueNode<T>? Tail { get; set; }
+        private int Count { get; set; } = 0;
+
+        public static Queue<T> Create()
+        {
+            //Create a new queue without a head / tail
+            return new Queue<T>();
+        }
+
+        public static Queue<T> Create(T? value)
+        {
+            //Create a new Queue with a head + tail
+            QueueNode<T> newNode = QueueNode<T>.Create(value, default);
+            return new Queue<T>
+            {
+                Head = newNode,
+                Tail = newNode,
+                Count = 1
+            };
+        }
+
+        public void Push(T? value)
+        {
+            //Add an Item to the end of the Queue
+            Count++;
+            if (Count > 1)
+            {
+                Tail!.Next = QueueNode<T>.Create(value, default);
+                Tail = Tail!.Next;
+                return;
+            }
+            Head = QueueNode<T>.Create(value, default);
+            Tail = Head;
+            return;
+        }
+
+        public T? Pop()
+        {
+            //Take the item off the front of the queue
+            T? value = default;
+            if (Count > 0)
+            {//Assign the default value if there are any items left in the Queue
+                Count--;
+                value = Head!.Value;
+                Head = Head.Next;
+                if (Count == 0)
+                {
+                    Head = default;
+                    Tail = Head;
+                }
+            }
+            return value;
+        }
+
+        public T? Peek()
+        {
+            //View item at the front of the Queue
+            if (Count > 0)
+            {
+                return Head!.Value;
+            }
+            return default;
+        }
+
+        public int GetCount()
+        {//Return the number of items in the list
+            return Count;
+        }
+    }
+}

C#/Datastructures/Queue/QueueNode.cs

@@ -0,0 +1,16 @@
+using C_.Datastructures.Generic;
+
+namespace C_.Datastructures.Queue
+{
+    internal class QueueNode<T> : UndirectedNode<T, QueueNode<T>>
+    {
+        public static QueueNode<T> Create(T? value, QueueNode<T>? next)
+        {
+            return new QueueNode<T>
+            {
+                Value = value,
+                Next = next
+            };
+        }
+    }
+}

C#/Datastructures/Stack/Stack.cs

@@ -1,52 +1,64 @@
-using C_.Datastructures.Nodes;
-
-namespace C_.Datastructures
+namespace C_.Datastructures.Stack
 {
     public class Stack<T>
     {
         internal StackNode<T>? Head { get; set; }
         private int Count { get; set; } = 0;
 
-        public static Stack<T> Create(){
+        public static Stack<T> Create()
+        {
             //Create a new stack without a head
             return new Stack<T>();
         }
 
-        public static Stack<T> Create(T value){
+        public static Stack<T> Create(T? value)
+        {
             //Create a new Stack with a head
-            return new Stack<T>{
+            return new Stack<T>
+            {
                 Head = StackNode<T>.Create(value, default),
                 Count = 1
             };
         }
 
-        public void Push(T value){
-            //Add an Item to the end of the list
-            if (Count > 0)
-            {    
-                Count++;
-                Head = StackNode<T>.Create(value, Head);
-                return;
-            }
+        public void Push(T? value)
+        {
+            //Add an Item to the top of the stack
+            Count++;
+            Head = StackNode<T>.Create(value, Head);
+            return;
         }
 
-        public T? Pop(){
+        public T? Pop()
+        {
+            //Take the item off of the top of the stack
             T? value = default;
             if (Count > 0)
             {//Assign the default value if there are any items left in the stack
                 Count--;
                 value = Head!.Value;
                 Head = Head.Next;
+                if (Count == 0)
+                {
+                    Head = default;
+                }
             }
             return value;
         }
 
-        public T? Peek(){
+        public T? Peek()
+        {
+            //View item on top of the stack
             if (Count > 0)
             {
                 return Head!.Value;
             }
             return default;
         }
+
+        public int GetCount()
+        {//Return the number of items in the list
+            return Count;
+        }
     }
 }

C#/Datastructures/Stack/StackNode.cs

@@ -1,11 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
+using C_.Datastructures.Generic;
 
-namespace C_.Datastructures.Nodes
+namespace C_.Datastructures.Stack
 {
-    internal class StackNode<T> : Node<T, StackNode<T>>
+    internal class StackNode<T> : UndirectedNode<T, StackNode<T>>
     {//Inherits from Node
         public static StackNode<T> Create(T? value, StackNode<T>? next)
         {

C#/Program.cs

@@ -1,6 +1,5 @@
 using System;
-using C_.Datastructures;
-using C_.Datastructures.Nodes;
+using C_.Datastructures.BinaryTree;
 
 // See https://aka.ms/new-console-template for more information
 Console.WriteLine("Hello, World!");
@@ -21,6 +20,13 @@ Console.WriteLine("Hello, World!");
 
 
 
+
+
+
+
+
+
+
 // DoublyLinkedList<int> list = new DoublyLinkedList<int>();
 
 // list.Append(1);
@@ -40,10 +46,94 @@ Console.WriteLine("Hello, World!");
 // Console.Write($"{list[6]} \n");
 
 
-Stack<int> test = Stack<int>.Create();
 
 
 
+
+
+//Stack<int> stack = Stack<int>.Create();
+
+//stack.Push(1);
+//stack.Push(2);
+//stack.Push(3);
+//stack.Push(4);
+//stack.Push(5);
+//stack.Push(6);
+
+//Console.WriteLine(stack.Peek());
+
+//stack.Pop();
+//stack.Push(7);
+
+//stack.Pop();
+//stack.Pop();
+//stack.Pop();
+//stack.Pop();
+//stack.Pop();
+//stack.Pop();
+
+
+
+
+
+
+
+//Queue<int> queue = Queue<int>.Create();
+
+//queue.Push(1);
+//queue.Push(2);
+//queue.Push(3);
+//queue.Push(4);
+//queue.Push(5);
+//queue.Push(6);
+
+//Console.WriteLine(queue.Peek());
+
+//queue.Pop();
+//queue.Push(7);
+
+//queue.Pop();
+//queue.Pop();
+//queue.Pop();
+//queue.Pop();
+//queue.Pop();
+//queue.Pop();
+
+
+
+
+
+
+
+
+
+
+
+
+Tree<int> tree = new Tree<int>();
+
+tree.Add(40);
+tree.Add(30);
+tree.Add(50);
+tree.Add(25);
+tree.Add(35);
+tree.Add(45);
+tree.Add(60);
+tree.Add(15);
+tree.Add(28);
+tree.Add(55);
+tree.Add(70);
+
+
+//var x = tree.Delete(10);
+//tree.Delete(5);
+
+var inorder = tree.Traverse(TraversalType.Inorder);
+var preorder = tree.Traverse(TraversalType.Preorder);
+var postorder = tree.Traverse(TraversalType.Postorder);
+var breadthFirst = tree.Traverse(TraversalType.Breadth);
+
+
 Console.ReadLine();
 
 

README.md

@@ -1,6 +1,6 @@
 # DataStructures
 
-List of DataStructures implemented in C#, Go & Rust  
+List of DataStructures implemented in C#, Go And C++  
 
 ## What is Included
 
@@ -10,7 +10,7 @@ Linked List
 Doubly Linked List  
 Stack  
 Queue  
-Binary Search Tree  
+Binary Tree  
 Heap  
 
 ### Algorithms