Updated repo to be C# only

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

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

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

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

@@ -0,0 +1,161 @@
+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()
+        {
+            //Create a new empty list
+            return new LinkedList<T>();
+        }
+
+        public static LinkedList<T> Create(T? value)
+        {
+            //Create a new Class with a single item
+            return new LinkedList<T>()
+            {
+                Head = LinkedListNode<T>.Create(value, null),
+                Count = 1
+            };
+        }
+
+        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;
+
+            //Find end of list and append fist item of next list
+            if (list2 == null || list.Count == 0) return list;
+
+            LinkedListNode<T>? end = list.Traverse();
+            end!.Next = list2!.Head;
+            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
+                LinkedListNode<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
+                LinkedListNode<T>? node = Traverse(i);
+                node!.Value = 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)
+            {
+                Head = newItem;
+                return;
+            }
+
+            //Find last item in list
+            LinkedListNode<T>? end = Head;
+            if (end != null)
+            {
+                end = Traverse();
+            }
+
+            //Append item to end
+            end!.Next = newItem;
+        }
+
+        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 = LinkedListNode<T>.Create(value, Head);
+                return;
+            }
+
+            //Fetch point in list at which item will be added
+            LinkedListNode<T>? node = Traverse(index - 1);
+
+            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 != default)
+            {
+                Head = Head!.Next;
+                return;
+            }
+
+            //Find node before the one we are trying to delete and then remove / relink
+            LinkedListNode<T>? node = Traverse(index - 1);
+
+            node!.Next = node.Next!.Next;
+        }
+
+        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)
+                {
+                    node = (LinkedListNode<T>)node.Next;
+                }
+            }
+            return node;
+        }
+
+        private LinkedListNode<T>? Traverse(int i)
+        {
+            //Start at given point in list
+            LinkedListNode<T>? node = Head;
+            if (node != null || i == 0)
+            {
+                //Continue to end of list
+                for (int j = 0; j < i; j++)
+                {
+                    if (node!.Next == null) return null;
+                    node = (LinkedListNode<T>)node.Next;
+                }
+            }
+            return node;
+        }
+    }
+}

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

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

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

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