luke-else/DataStructuresCSharp
1
0
Fork 0
Code Issues 6 Pull Requests Projects 1 Releases Wiki Activity

Updated repo to be C# only

Browse Source
This commit is contained in:
Luke Else
2022-11-04 12:03:03 +00:00
parent e2157e7093
commit 0dfb647f8f
18 changed files with 2 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
Datastructures/BinaryTree/Tree.cs Normal file
View File

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

28
Datastructures/BinaryTree/TreeNode.cs Normal file
View File

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

214
Datastructures/DoublyLinkedList/DoublyLinkedList.cs Normal file
View File

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

19
Datastructures/DoublyLinkedList/DoublyLinkedListNode.cs Normal file
View File

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

15
Datastructures/Generic/DirectedNode.cs Normal file
View File

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

10
Datastructures/Generic/UndirectedNode.cs Normal file
View File

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

44
Datastructures/Heap/Heap.cs Normal file
View File

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

38
Datastructures/Heap/HeapNode.cs Normal file
View File

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

161
Datastructures/LinkedList/LinkedList.cs Normal file
View File

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

16
Datastructures/LinkedList/LinkedListNode.cs Normal file
View File

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

75
Datastructures/Queue/Queue.cs Normal file
View File

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

16
Datastructures/Queue/QueueNode.cs Normal file
View File

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

64
Datastructures/Stack/Stack.cs Normal file
View File

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

16
Datastructures/Stack/StackNode.cs Normal file
View File

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