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.cs

@@ -1,126 +0,0 @@
-using System;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using C_.Datastructures.Nodes;
-
-namespace C_.Datastructures
-{
-    internal class DoublyLinkedList<T>
-    {
-        internal DoublyLinkedListNode<T>? Head { get; set; } = default;
-        internal DoublyLinkedListNode<T>? Tail { get; set; } = default;
-        private int Count { get; set; } = 0;
-
-        public static DoublyLinkedList<T> Create()
-        {
-            //Create a new empty list
-            return new DoublyLinkedList<T>();
-        }
-
-        public static DoublyLinkedList<T> Create(T value)
-        {
-            //Create a new Class with a single item
-            return new DoublyLinkedList<T>()
-            {
-                Head = DoublyLinkedListNode<T>.Create(value, null, null),
-                Count = 1
-            };
-        }
-
-        public T? this[int i]
-        {
-            get
-            {
-                //Check Range
-                if (i >= Count || i < 0) throw new System.Exception("Error! Index out of Bounds");
-
-                //Return Value
-                DoublyLinkedListNode<T>? node = Traverse(i);
-                if (node != null) return node.Value;
-                return default;
-            }
-            set
-            {
-                //Check Range
-                if (i >= Count || i < 0) throw new System.Exception("Error! Index out of Bounds");
-
-                //Change Value
-                DoublyLinkedListNode<T>? node = Traverse(i);
-                node!.Value = value;
-            }
-        }
-        public void Add(T value)
-        {
-            Count++;
-
-            if (Tail != null && Count > 0)
-            {
-                Tail.Next = new DoublyLinkedListNode<T> { Value = value, Next = null, Prev = Tail };
-                Tail = Tail.Next;
-                return;
-            }
-
-            Head = new DoublyLinkedListNode<T> { Value = value, Next = null, Prev = null };
-            Tail = Head;
-            
-        }
-
-
-        private DoublyLinkedListNode<T>? Traverse()
-        {
-            //Return the final item in the list
-            return Tail;
-        }
-
-        private DoublyLinkedListNode<T>? Traverse(int i)
-        {
-            //Determine whether to start at the start or end of the list
-            int direction = 1;
-            DoublyLinkedListNode<T>? node = Head;
-
-            if (i > (Count/2))
-            {
-                //reverse direction of search
-                direction = -1;
-                node = Tail;
-                //i becomes the amount of hops left to reach the item
-                i = Count - i - 1;
-            }
-
-            if (node != null)
-            {
-
-                //continue to given point in the list ('i' hops)
-                for (int x = 0; x < i; x++)
-                {
-                    if (direction == 1)
-                    {//Going forwards
-                        node = node!.Next;
-                    }
-                    else
-                    {
-                        node = node!.Prev;
-                    }
-
-                }
-            }
-            return node;
-        }
-        private DoublyLinkedListNode<T>? Next(DoublyLinkedListNode<T> current)
-        {
-            if (current != null)
-                return current.Next;
-
-            return null;
-        }
-
-        private DoublyLinkedListNode<T>? Prev(DoublyLinkedListNode<T> current)
-        {
-            if (current != null)
-                return current.Prev;
-
-            return null;
-        }
-    }
-}

C#/Datastructures/DoublyLinkedList/DoublyLinkedList.cs

@@ -0,0 +1,214 @@
+namespace C_.Datastructures.DoublyLinkedList
+{
+    public class DoublyLinkedList<T>
+    {
+        internal DoublyLinkedListNode<T>? Head { get; set; } = default;
+        internal DoublyLinkedListNode<T>? Tail { get; set; } = default;
+        private int Count { get; set; } = 0;
+
+        public static DoublyLinkedList<T> Create()
+        {
+            //Create a new empty list
+            return new DoublyLinkedList<T>();
+        }
+
+        public static DoublyLinkedList<T> Create(T? value)
+        {
+            //Create a new Class with a single item
+            return new DoublyLinkedList<T>()
+            {
+                Head = DoublyLinkedListNode<T>.Create(value, default, default),
+                Count = 1
+            };
+        }
+
+        public static DoublyLinkedList<T> Create(DoublyLinkedList<T> list1, DoublyLinkedList<T> list2)
+        {
+            //Create a new list from 2 separate lists
+
+            DoublyLinkedList<T> list;
+
+            list = list1;
+            if (list == default || list.Count == 0) return list2;
+
+            //Find end of list and append fist item of next list
+            if (list2 == default || list.Count == 0) return list;
+
+            DoublyLinkedListNode<T>? end = list.Traverse();
+
+            //Connect up pointers at ajoining section
+            end!.Next = list2!.Head;
+            end!.Next!.Prev = end;
+            end = list2.Tail;
+            list.Count += list2!.Count;
+
+            return list;
+        }
+
+        public T? this[int i]
+        {
+            get
+            {
+                //Check Range
+                if (i >= Count || i < 0) throw new System.Exception("Error! Index out of Bounds");
+
+                //Return Value
+                DoublyLinkedListNode<T>? node = Traverse(i);
+                if (node != default) return node.Value;
+                return default;
+            }
+            set
+            {
+                //Check Range
+                if (i >= Count || i < 0) throw new System.Exception("Error! Index out of Bounds");
+
+                //Change Value
+                DoublyLinkedListNode<T>? node = Traverse(i);
+                node!.Value = value;
+            }
+        }
+        public void Append(T? value)
+        {
+            Count++;
+
+            //Set head to new item if list is empty
+            if (Head == null)
+            {//Append item to front of list (End as well)
+                Head = DoublyLinkedListNode<T>.Create(value, default, default);
+                Tail = Head;
+                return;
+            }
+
+            //Append item to the end of the list
+            Tail!.Next = DoublyLinkedListNode<T>.Create(value, default, Tail);
+            Tail = Tail.Next;
+        }
+
+        public void Insert(int index, T? value)
+        {
+            Count++;
+            if (index > Count || index < 0) throw new System.Exception("Error! Index outside of Bounds");
+
+            //Set head to new item if list is empty
+            if (index == 0 || Head == null)
+            {
+                Head = DoublyLinkedListNode<T>.Create(value, Head, default);
+                Tail = Head;
+                return;
+            }
+
+            //Set tail to new item if index is the end
+            if (index == Count - 1)
+            {
+                //Decrement count as it will be be re-incremented once appended
+                Count--;
+                Append(value);
+                return;
+            }
+
+            //Fetch point in list and add new item
+            DoublyLinkedListNode<T>? node = Traverse(index - 1);
+            node!.Next = DoublyLinkedListNode<T>.Create(value, node.Next, node);
+
+            //Create backlink in the list
+            if (node.Next.Next != default)
+                node.Next.Next.Prev = node.Next;
+        }
+
+        public void Delete(int index)
+        {
+            Count--;
+            if (index > Count || index < 0) throw new System.Exception("Error! Index outside of Bounds");
+
+            //Check if we are trying to reference the first item
+            if (index == 0 && Head != default)
+            {
+                Head = Head!.Next;
+                if (Head != default)
+                    Head.Prev = default;
+                return;
+            }
+
+            //Set tail to new item if index is the end
+            if (index == Count && Tail != default)
+            {
+                Tail = Tail!.Prev;
+
+                if (Tail != default)
+                    Tail.Next = default;
+                return;
+            }
+
+            DoublyLinkedListNode<T>? node = Traverse(index - 1);
+
+            node!.Next = node.Next!.Next;
+
+            //Connect item after to the the item before the node we are deleting
+            if (node.Next != default)
+            {
+                node.Next.Prev = node;
+            }
+        }
+
+        public int GetCount()
+        {//Return the number of items in the list
+            return Count;
+        }
+
+        private DoublyLinkedListNode<T>? Traverse()
+        {
+            //Return the final item in the list
+            return Tail;
+        }
+
+        private DoublyLinkedListNode<T>? Traverse(int i)
+        {
+            //Determine whether to start at the start or end of the list
+            int direction = 1;
+            DoublyLinkedListNode<T>? node = Head;
+
+            if (i > (Count / 2))
+            {
+                //reverse direction of search
+                direction = -1;
+                node = Tail;
+                //i becomes the amount of hops left to reach the item
+                i = Count - i - 1;
+            }
+
+            if (node != null)
+            {
+
+                //continue to given point in the list ('i' hops)
+                for (int x = 0; x < i; x++)
+                {
+                    if (direction == 1)
+                    {//Going forwards
+                        node = node!.Next;
+                    }
+                    else
+                    {
+                        node = node!.Prev;
+                    }
+
+                }
+            }
+            return node;
+        }
+        private DoublyLinkedListNode<T>? Next(DoublyLinkedListNode<T> current)
+        {
+            if (current != default)
+                return current.Next;
+
+            return null;
+        }
+
+        private DoublyLinkedListNode<T>? Prev(DoublyLinkedListNode<T> current)
+        {
+            if (current != default)
+                return current.Prev;
+
+            return null;
+        }
+    }
+}

C#/Datastructures/DoublyLinkedList/DoublyLinkedListNode.cs

@@ -0,0 +1,19 @@
+using C_.Datastructures.Generic;
+
+namespace C_.Datastructures.DoublyLinkedList
+{
+    internal class DoublyLinkedListNode<T> : UndirectedNode<T, DoublyLinkedListNode<T>>
+    {//Inherits from Node
+        internal DoublyLinkedListNode<T>? Prev { get; set; } = default;
+
+        public static DoublyLinkedListNode<T> Create(T? value, DoublyLinkedListNode<T>? next, DoublyLinkedListNode<T>? prev)
+        {
+            return new DoublyLinkedListNode<T>
+            {
+                Value = value,
+                Next = next,
+                Prev = 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,35 +1,33 @@
-using C_.Datastructures.Nodes;
-
-namespace C_.Datastructures
+namespace C_.Datastructures.LinkedList
 {
-    internal class LinkedList<T>
+    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)
-            {
-                //If list 2 is the only list present
-                return list2;
-            }
+            if (list == null || list.Count == 0) return list2;
 
             //Find end of list and append fist item of next list
             if (list2 == null || list.Count == 0) return list;
@@ -56,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);
@@ -64,12 +62,14 @@ namespace C_.Datastructures
             }
         }
 
-        public void Append(T value){
-            LinkedListNode<T> newItem = LinkedListNode<T>.Create(value, default);
+        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;
@@ -81,50 +81,58 @@ namespace C_.Datastructures
             {
                 end = Traverse();
             }
-            
+
             //Append item to end
-            end!.Next = new LinkedListNode<T>{
-                Value = value,
-                Next = default
-            };
+            end!.Next = newItem;
         }
 
-        public void Insert(int index, T value)
+        public void Insert(int index, T? value)
         {
-            if (index > Count) throw new System.Exception("Error! Index outside of Bounds");
+            Count++;
+            if (index > Count || index < 0) throw new System.Exception("Error! Index outside of Bounds");
+
+            //Set head to new item if list is empty
+            if (index == 0 || Head == null)
+            {
+                Head = LinkedListNode<T>.Create(value, Head);
+                return;
+            }
 
             //Fetch point in list at which item will be added
             LinkedListNode<T>? node = Traverse(index - 1);
-            node!.Next = new LinkedListNode<T> { 
-                Value = value, 
-                Next = node.Next 
-            };
-            Count++;
+
+            node!.Next = LinkedListNode<T>.Create(value, node!.Next);
         }
 
         public void Delete(int index)
         {
+            Count--;
+            if (index > Count || index < 0) throw new System.Exception("Error! Index outside of Bounds");
+
             //Check if we are trying to reference the first item
-            if (index == 0 && Head != null)
+            if (index == 0 && Head != default)
             {
-                Head = (LinkedListNode<T>?)Head!.Next;
+                Head = Head!.Next;
                 return;
             }
 
-            //Find node we are trying to delete and then remove / relink
+            //Find node before the one we are trying to delete and then remove / relink
             LinkedListNode<T>? node = Traverse(index - 1);
 
-            if (node == null || node.Next == null) throw new System.Exception("Error! Index outside of Bounds");
-
-            node.Next = node.Next.Next;
-            Count--;
+            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)
                 {
@@ -134,28 +142,14 @@ 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 n)
+        private LinkedListNode<T>? Traverse(int i)
         {
             //Start at given point in list
             LinkedListNode<T>? node = Head;
-            if (node != null || n == 0)
+            if (node != null || i == 0)
             {
                 //Continue to end of list
-                for (int i = 0; i < n; i++)
+                for (int j = 0; j < i; j++)
                 {
                     if (node!.Next == null) return null;
                     node = (LinkedListNode<T>)node.Next;

C#/Datastructures/LinkedList/LinkedListNode.cs

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

C#/Datastructures/Nodes/DoublyLinkedListNode.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace C_.Datastructures.Nodes
-{
-    internal class DoublyLinkedListNode<T>
-    {
-        public T? Value { get; set; } = default;
-        public DoublyLinkedListNode<T>? Next { get; set; } = default;
-
-        public DoublyLinkedListNode<T>? Prev { get; set; } = default;
-
-        public static DoublyLinkedListNode<T> Create(T? value, DoublyLinkedListNode<T>? next, DoublyLinkedListNode<T>? prev)
-        {
-            return new DoublyLinkedListNode<T>
-            {
-                Value = value,
-                Next = next,
-                Prev = prev
-            };
-        }
-    }
-}

C#/Datastructures/Nodes/LinkedListNode.cs

@@ -1,23 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace C_.Datastructures.Nodes 
-{
-    internal class LinkedListNode<T>
-    {
-        public T? Value { get; set; } = default;
-        public LinkedListNode<T>? Next { get; set; } = default;
-
-        public static LinkedListNode<T> Create(T? value, LinkedListNode<T>? next)
-        {
-            return new LinkedListNode<T>
-            {
-                Value = value,
-                Next = next
-            };
-        }
-    }
-}

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

@@ -0,0 +1,64 @@
+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()
+        {
+            //Create a new stack without a head
+            return new Stack<T>();
+        }
+
+        public static Stack<T> Create(T? value)
+        {
+            //Create a new Stack with a head
+            return new Stack<T>
+            {
+                Head = StackNode<T>.Create(value, default),
+                Count = 1
+            };
+        }
+
+        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()
+        {
+            //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()
+        {
+            //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

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

C#/Program.cs

@@ -1,22 +1,140 @@
 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!");
 
-DoublyLinkedList<int> list = new DoublyLinkedList<int>();
 
-list.Add(1);
-list.Add(2);
-list.Add(3);
-list.Add(4);
-list.Add(5);
-list.Add(6);
-list.Add(7);
-list.Add(8);
+//LinkedList<int> list = new LinkedList<int>();
+
+//list.Append(1);
+//list.Append(2);
+//list.Append(3);
+//list.Append(4);
+//list.Append(5);
+//list.Append(6);
+
+//list.Delete(5);
+//list.Delete(2);
+//list.Delete(0);
+
+
+
+
+
+
+
+
+
+
+// DoublyLinkedList<int> list = new DoublyLinkedList<int>();
+
+// list.Append(1);
+// list.Append(2);
+// list.Append(3);
+// list.Append(4);
+// list.Append(5);
+// list.Append(6);
+// list.Insert(6, 1);
+
+// Console.Write($"{list[0]} ");
+// Console.Write($"{list[1]} ");
+// Console.Write($"{list[2]} ");
+// Console.Write($"{list[3]} ");
+// Console.Write($"{list[4]} ");
+// Console.Write($"{list[5]} ");
+// Console.Write($"{list[6]} \n");
+
+
+
+
+
+
+
+//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();
 
-var x = list[-6];
 
-Console.WriteLine(x);
 

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