Updated repo to be C# only

Traversals to be selected using enum

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#/Program.cs

@@ -1,50 +0,0 @@
-using System;
-using C_.Datastructures;
-using C_.Datastructures.Nodes;
-
-// See https://aka.ms/new-console-template for more information
-Console.WriteLine("Hello, World!");
-
-
-//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> test = Stack<int>.Create();
-
-
-
-Console.ReadLine();
-
-
-

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
+    }
+}

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
+            };
+        }
+    }
+}

Datastructures/DoublyLinkedList/DoublyLinkedList.cs

@@ -1,10 +1,4 @@
-using System;
+namespace C_.Datastructures.DoublyLinkedList
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using C_.Datastructures.Nodes;
-
-namespace C_.Datastructures
 {
     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,7 +22,6 @@ namespace C_.Datastructures
             };
         }
 
-
         public static DoublyLinkedList<T> Create(DoublyLinkedList<T> list1, DoublyLinkedList<T> list2)
         {
             //Create a new list from 2 separate lists
@@ -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;
             }
@@ -157,6 +150,10 @@ namespace C_.Datastructures
             }
         }
 
+        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;

Datastructures/DoublyLinkedList/DoublyLinkedListNode.cs

@@ -1,14 +1,10 @@
-using System;
+using C_.Datastructures.Generic;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
-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)
         {

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;
+    }
+}

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;
+    }
+}

Datastructures/Heap/Heap.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace C_.Datastructures.Heap
+{
+    internal class Heap<T> where T:IComparable
+    {
+        internal HeapNode<T>? Root { get; set; }
+        private int Count { get; set; }
+
+        public static Heap<T> Create(){
+            return new Heap<T>{
+                Root = null,
+                Count = 0
+            };
+        }
+
+        public static Heap<T> Create(T value){
+            return new Heap<T>{
+                Root = HeapNode<T>.Create(value),
+                Count = 1
+            };
+        }
+
+        public void Add(T value){
+            Count++;
+
+            if (Root == default)
+            {//If the new node needs to be added to the top of the heap
+                Root = HeapNode<T>.Create(value);
+                return;
+            }
+
+            //If the new node can be placed in a subchild
+            HeapNode<T> node = Root;
+
+            while(node.Left != default){
+                node = node.Left;
+            }
+        }
+    }
+}

Datastructures/Heap/HeapNode.cs

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

Datastructures/LinkedList/LinkedList.cs

@@ -1,26 +1,28 @@
-using C_.Datastructures.Nodes;
+namespace C_.Datastructures.LinkedList
-
-namespace C_.Datastructures
 {
     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;
 
@@ -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,7 +62,8 @@ 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);
@@ -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,7 +122,13 @@ 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)
@@ -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

Datastructures/LinkedList/LinkedListNode.cs

@@ -1,12 +1,8 @@
-using System;
+using C_.Datastructures.Generic;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
-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)
         {

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;
+        }
+    }
+}

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
+            };
+        }
+    }
+}

Datastructures/Stack/Stack.cs

@@ -1,52 +1,64 @@
-using C_.Datastructures.Nodes;
+namespace C_.Datastructures.Stack
-
-namespace C_.Datastructures
 {
     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){
+        public void Push(T? value)
-            //Add an Item to the end of the list
-            if (Count > 0)
         {
+            //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;
+        }
     }
 }

Datastructures/Stack/StackNode.cs

@@ -1,11 +1,8 @@
-using System;
+using C_.Datastructures.Generic;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
 
-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)
         {

Program.cs

@@ -0,0 +1,153 @@
+using System;
+using C_.Datastructures.DoublyLinkedList;
+using C_.Datastructures.BinaryTree;
+using C_.Datastructures.Heap;
+
+// See https://aka.ms/new-console-template for more information
+Console.WriteLine("Hello, World!");
+
+
+//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);
+
+// list.Delete(0);
+
+// 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);
+
+
+
+
+
+
+
+var x = HeapNode<int>.Create(1, null, new HeapNode<int> { Left = default, Right = default });
+
+Console.ReadLine();
+
+
+
+
+
+
+
+

README.md

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