public static void Main()
{
// Create a new doubly linked list of type int.
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
Console.WriteLine("Populate new doubly linked list that is NOT a palindrome...");
dll.AddFirst(3);
dll.AddLast(5);
dll.AddLast(7);
dll.AddLast(9);
Console.WriteLine("Print:");
dll.Print();
Console.WriteLine("Print Reverse:");
dll.PrintReverse();
// The IsPalindrome contains 3 methods:
// IsPalindrome: O(2n)
// ReverseAndCopy: O(n), with O(n) space.
// IsEqual: O(n)
// Runtime for IsPalindrome method execution: O(2n) -> O(n)
// with O(n) extra memory.
// Still trying to work in generics, only accepts type int right now.
Console.WriteLine($"Is linked list a palindrome: {dll.IsPalindrome(dll.Head)}");
Console.WriteLine();
Console.WriteLine("Clear linked list.");
dll.Clear();
Console.WriteLine($"Linked list is Empty: {dll.IsEmpty()}");
Console.WriteLine();
Console.WriteLine("Populate new doubly linked list that IS a palindrome...");
dll.AddFirst(3);
dll.AddLast(5);
dll.AddLast(7);
dll.AddLast(5);
dll.AddLast(3);
Console.WriteLine("Print:");
dll.Print();
Console.WriteLine("Print Reverse:");
dll.PrintReverse();
Console.WriteLine($"Is linked list a palindrome: {dll.IsPalindrome(dll.Head)}");
}
private void shrink()
{
if (Math.Abs(filledBuckets - bucketSize * 0.3) < tolerance && bucketSize / 2 > initialBucketSize)
{
filledBuckets = 0;
//reduce array by half
var newBucketSize = bucketSize / 2;
var smallerArray = new DoublyLinkedList <HashSetNode <T> > [newBucketSize];
for (int i = 0; i < bucketSize; i++)
{
var item = hashArray[i];
//hashcode changes when bucket size changes
if (item?.Head != null)
{
var current = item.Head;
//find new location for each item
while (current != null)
{
var next = current.Next;
var newIndex = Math.Abs(current.Data.Value.GetHashCode()) % newBucketSize;
if (smallerArray[newIndex] == null)
{
filledBuckets++;
smallerArray[newIndex] = new DoublyLinkedList <HashSetNode <T> >();
}
smallerArray[newIndex].InsertFirst(current);
current = next;
}
}
}
hashArray = smallerArray;
}
}
public static void Main()
{
// Declare new doubly linked list of type int, using Generics<T>.
// Big Oh notated below in Main.
DoublyLinkedList <int> ll = new DoublyLinkedList <int>();
Console.WriteLine("Populate new doubly linked list of type int.");
// AddFirst: O(1)
ll.AddFirst(3);
// Create new node to insert.
var n = new Node <int>(7);
// AddLast by node, O(1).
ll.AddLast(n);
// Insert 5 before the 7 node, O(n).
ll.AddBefore(n, 5);
// AddLast by value, O(1).
ll.AddLast(9);
Console.WriteLine("Print:");
ll.Print(); // O(n)
Console.WriteLine("Print Reverse:");
// Print Reverse: O(n)
ll.PrintReverse();
Console.WriteLine("Remove nodes using RemoveFirst, RemoveLast, Remove(value) methods.");
ll.Remove(7); // Remove by value (search): O(n)
ll.Print();
ll.RemoveFirst(); // O(1)
ll.Print();
ll.RemoveLast(); // O(1)
ll.Print();
ll.Clear(); // O(1)
Console.WriteLine("Clear linked list.");
Console.WriteLine($"Linked list is Empty: {ll.IsEmpty()}"); // O(1)
// The Upshot: Doubly Linked Lists improve all operations at Tail from O(n) to O(1).
// Still O(n) to search or print, methods requiring complete or partial iteration.
// I used a Count variable, unlike the single list, because they improve the code.
}
static void Main(string[] args)
{
DoublyLinkedList list = new DoublyLinkedList();
list.AddFirst("1");
list.AddFirst("2");
list.AddFirst("3");
list.AddLast("4");
list.AddLast("5");
list.AddFirst("6");
list.DisplayList(); // 6 3 2 1 4 5
Console.WriteLine();
Console.WriteLine(list.GetAndRemoveFirst());
list.DisplayList(); // 3 2 1 4 5
Console.WriteLine();
Console.WriteLine(list.GetAndRemoveLast());
list.DisplayList(); // 3 2 1 4
var findEl = list[2];
Console.WriteLine();
list.InsertAfter(findEl, "7");
list.DisplayList(); // 3 2 1 7 4
findEl = list[1];
Console.WriteLine();
list.RemoveElement(findEl);
list.DisplayList(); // 3 1 7 4
Console.WriteLine();
list.AddFirst("8");
list.AddLast("9");
Console.ReadLine();
}
public static void Main()
{
// Declare new doubly linked list of type int, using Generics<T>.
// Big Oh notated below in Main.
DoublyLinkedList <int> ll = new DoublyLinkedList <int>();
Console.WriteLine("Populate new linked list using AddFirst, AddLast and AddBefore.");
// O(1)
ll.AddFirst(3);
// Create new node to insert.
var n = new Node <int>(7);
// AddLast by node, O(1).
ll.AddLast(n);
// Insert 5 before the 7 node, O(n).
ll.AddBefore(n, 5);
// AddLast by value, O(1).
ll.AddLast(9);
Console.WriteLine("Print:");
ll.Print(); // O(n)
Console.WriteLine("Print Reverse:");
// Print Reverse
ll.PrintReverse(); // O(n)
Console.WriteLine("Remove nodes using RemoveFirst, RemoveLast, Remove(value) methods.");
ll.Remove(7); // O(n)
ll.Print();
ll.RemoveFirst(); // O(1)
ll.Print();
ll.RemoveLast(); // O(1)
ll.Print();
ll.Clear(); // O(1)
Console.WriteLine("Clear linked list.");
Console.WriteLine($"Linked list is Empty: {ll.IsEmpty()}"); // O(1)
}
public Queue()
{
List = new DoublyLinkedList <T>();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//Single Linked List
Console.WriteLine("---Singly Linked List---");
SinglyLinkedList mySingly = new SinglyLinkedList();
mySingly.printList();
mySingly.addNode(5);
mySingly.addNode(69);
mySingly.addNode(420);
mySingly.addNode(666);
mySingly.printList();
mySingly.deleteNode(666);
mySingly.deleteNode(7);
mySingly.deleteNode(420);
mySingly.printList();
//Doubly Linked List
Console.WriteLine("---Doubly Linked List---");
DoublyLinkedList myDoubly = new DoublyLinkedList();
myDoubly.addNode(9);
myDoubly.addNode(10);
myDoubly.addNode(69);
myDoubly.addNode(420);
myDoubly.addNode(666);
myDoubly.printForward();
myDoubly.printReverse();
myDoubly.deleteNode(9);
myDoubly.deleteNode(69);
myDoubly.printForward();
myDoubly.printReverse();
//Binary Search Tree
Console.WriteLine("---Binary Search Tree---");
BinarySearchTree myTree = new BinarySearchTree();
int[] treeKey = { 69, 420, 77, 80, 13, 1, 8, 666, 71, 100 };
for (int i = 0; i < treeKey.Length; ++i)
{
myTree.addLeaf(treeKey[i]);
}
myTree.printInOrder();
Console.WriteLine();
Console.WriteLine("The smallest value in the tree is {0}", myTree.findSmallest());
myTree.removeNode(3);
myTree.removeNode(69);
myTree.removeNode(13);
myTree.printInOrder();
Console.WriteLine();
//Stack
Console.WriteLine("---Stack---");
StackClass myStack = new StackClass();
myStack.push("Bob", 5);
myStack.push("Amy", 69);
myStack.push("John wick", 100);
myStack.push("Nice", 420);
myStack.print();
myStack.pop();
myStack.pop();
myStack.print();
//Hash Table
Console.WriteLine("---Hash Table---");
HashTable myTable = new HashTable(10);
myTable.addItem("Paul", "Locha");
myTable.addItem("Kim", "Iced mocha");
myTable.addItem("Emma", "Strawberry smoothie");
myTable.addItem("Annie", "Hot Chocolate");
myTable.addItem("Sarah", "Passion Tea");
myTable.addItem("Pepper", "Caramel Mocha");
myTable.addItem("Mike", "Chai Tea");
myTable.addItem("Steve", "Apple Cider");
myTable.addItem("Bill", "Root Beer");
myTable.addItem("Marie", "Skinny Latte");
myTable.addItem("Susan", "Water");
myTable.addItem("Joe", "Green Tea");
myTable.printTable();
myTable.printItemsInIndex(4);
myTable.removeItem("Marie");
myTable.printItemsInIndex(4);
}
public void TestDoublyLinkedList()
{
int retVal;
DoublyLinkedList dll = new DoublyLinkedList(5);
// Push()
dll.DeleteAt(0);
dll.Push(1); // LL is empty
Assert.AreEqual(new List<int>() { 1 }, dll.ReturnList());
dll.Push(2); // LL.count == 1
Assert.AreEqual(new List<int>() { 2, 1 }, dll.ReturnList());
dll.Push(3); // LL.count > 1
Assert.AreEqual(new List<int>() { 3, 2, 1 }, dll.ReturnList());
// Delete()
dll.InitializeDLL();
retVal = dll.Delete(111); // doesn't exist
Assert.AreEqual(new List<int>() { 5, 4, 3, 2, 1,0 }, dll.ReturnList());
Assert.AreEqual(-1, retVal);
retVal = dll.Delete(0); // exists at tail
Assert.AreEqual(new List<int>() { 5, 4, 3, 2, 1 }, dll.ReturnList());
Assert.AreEqual(0, retVal);
retVal = dll.Delete(5); // exists at head
Assert.AreEqual(new List<int>() { 4, 3, 2, 1 }, dll.ReturnList());
Assert.AreEqual(5, retVal);
retVal = dll.Delete(3); // exists between head and tail
Assert.AreEqual(new List<int>() { 4, 2, 1 }, dll.ReturnList());
Assert.AreEqual(3, retVal);
// DeleteAt()
dll.InitializeDLL();
retVal = dll.DeleteAt(-23); // invalid index
Assert.AreEqual(new List<int>() { 5, 4, 3, 2, 1, 0 }, dll.ReturnList());
Assert.AreEqual(-1, retVal);
retVal = dll.DeleteAt(7); // invalid index
Assert.AreEqual(new List<int>() { 5, 4, 3, 2, 1, 0 }, dll.ReturnList());
Assert.AreEqual(-1, retVal);
retVal = dll.DeleteAt(0); // exists at head
Assert.AreEqual(new List<int>() { 4, 3, 2, 1, 0 }, dll.ReturnList());
Assert.AreEqual(5, retVal);
retVal = dll.DeleteAt(4); // exists at tail
Assert.AreEqual(new List<int>() { 4, 3, 2, 1 }, dll.ReturnList());
Assert.AreEqual(0, retVal);
retVal = dll.DeleteAt(1); // exists between head and tail
Assert.AreEqual(new List<int>() { 4, 2, 1 }, dll.ReturnList());
Assert.AreEqual(3, retVal);
// Search()
dll.InitializeDLL();
Assert.AreEqual(-1, dll.Search(111)); // doesn't exist
Assert.AreEqual(5, dll.Search(5)); // exists at head
Assert.AreEqual(0, dll.Search(0)); // exists at tail
Assert.AreEqual(3, dll.Search(3)); // exists in between head and tail
Assert.AreEqual(new List<int>() { 5, 4, 3, 2, 1, 0 }, dll.ReturnList());
// Append()
dll = new DoublyLinkedList(0);
dll.DeleteAt(0);
dll.Append(0); // LL is empty
Assert.AreEqual(new List<int>() { 0 }, dll.ReturnList());
dll.Append(1); // LL.count = 1
Assert.AreEqual(new List<int>() { 0, 1 }, dll.ReturnList());
dll.Append(2);
Assert.AreEqual(new List<int>() { 0, 1, 2 }, dll.ReturnList());
dll.Append(3); // LL.count > 1
Assert.AreEqual(new List<int>() { 0, 1, 2, 3 }, dll.ReturnList());
// Pop()
dll = new DoublyLinkedList(0);
dll.Append(1);
dll.Append(2);
Assert.AreEqual(2, dll.Pop()); // LL.count > 1;
Assert.AreEqual(new List<int>() { 0, 1 }, dll.ReturnList());
Assert.AreEqual(1, dll.Pop()); // LL.count > 1;
Assert.AreEqual(new List<int>() { 0 }, dll.ReturnList());
Assert.AreEqual(0, dll.Pop()); // LL.count == 1;
Assert.AreEqual(new List<int>(), dll.ReturnList());
Boolean isException = false;
try
{
dll.Pop();
}
catch
{
isException = true;
}
Assert.IsTrue(isException);
}
internal ListElement(string value, DoublyLinkedList ownerList)
{
Value = value;
OwnerList = ownerList;
}
