public void TestIfInsertIntoLinkList()
{
SLinkedList newList = new SLinkedList();
newList.Insert(5);
Assert.Equal(5, newList.Head.Value);
}
public void TestVowelList()
{
SLinkedList <string> vowels = new SLinkedList <string>();
vowels.Append("a");
vowels.Append("e");
vowels.Append("i");
vowels.Append("o");
vowels.Append("u");
SNode <string> head = vowels.Head;
var it = vowels.GetIterator();
Assert.AreEqual("a", it.GetData()); it.MoveNext();
Assert.AreEqual("e", it.GetData()); it.MoveNext();
Assert.AreEqual("i", it.GetData()); it.MoveNext();
Assert.AreEqual("o", it.GetData()); it.MoveNext();
Assert.AreEqual("u", it.GetData()); it.MoveNext();
//foreach (var vowel in vowels)
//{
// Console.WriteLine(vowel);
//}
}
public void TestIfHeadPointsToFirstNode()
{
SLinkedList newList = new SLinkedList();
newList.Insert(5);
newList.Insert(25);
Assert.Equal(5, newList.Head.Next.Value);
}
public static void DoTest()
{
int index = 0;
SLinkedList <int> listOfNumbers1 = new SLinkedList <int>();
listOfNumbers1.Append(10);
listOfNumbers1.Append(124);
listOfNumbers1.Prepend(654);
listOfNumbers1.Prepend(8);
listOfNumbers1.Append(127485693);
listOfNumbers1.Append(34);
listOfNumbers1.Append(823);
listOfNumbers1.RemoveAt(0);
listOfNumbers1.RemoveAt(3);
listOfNumbers1.RemoveAt(4);
listOfNumbers1.RemoveAt(2);
listOfNumbers1.RemoveAt(2);
listOfNumbers1.RemoveAt(0);
listOfNumbers1.Prepend(3);
listOfNumbers1.Prepend(2);
listOfNumbers1.Prepend(1);
// Print List and Count
listOfNumbers1.InsertAt(444, listOfNumbers1.Count);
listOfNumbers1.InsertAt(555, listOfNumbers1.Count);
listOfNumbers1.InsertAt(222, 2);
index = (listOfNumbers1.Count - 1);
var arrayVersion = listOfNumbers1.ToArray();
Assert.True(arrayVersion.Length == listOfNumbers1.Count);
/************************************************************************************/
var listOfNumbers2 = new SLinkedList <int>();
listOfNumbers2.Append(23);
listOfNumbers2.Append(42);
listOfNumbers2.Append(4);
listOfNumbers2.Append(16);
listOfNumbers2.Append(8);
listOfNumbers2.Append(15);
listOfNumbers2.Append(9);
listOfNumbers2.Append(55);
listOfNumbers2.Append(0);
listOfNumbers2.Append(34);
listOfNumbers2.Append(12);
listOfNumbers2.Append(2);
listOfNumbers2.SelectionSort();
var intArray = listOfNumbers2.ToArray();
Assert.True(intArray[0] == 0 && intArray[intArray.Length - 1] == 55, "Wrong sorting!");
}
public static void DoTest()
{
SLinkedList <int> listOfNumbers1 = new SLinkedList <int>();
listOfNumbers1.Append(10);
listOfNumbers1.Append(124);
listOfNumbers1.Prepend(654);
listOfNumbers1.Prepend(8);
listOfNumbers1.Append(127485693);
listOfNumbers1.Append(34);
listOfNumbers1.Append(824);
listOfNumbers1.RemoveAt(0);
listOfNumbers1.RemoveAt(3);
listOfNumbers1.RemoveAt(4);
listOfNumbers1.RemoveAt(2);
listOfNumbers1.RemoveAt(2);
listOfNumbers1.RemoveAt(0);
listOfNumbers1.Prepend(3);
listOfNumbers1.Prepend(2);
listOfNumbers1.Prepend(1);
listOfNumbers1.InsertAt(444, listOfNumbers1.Count);
listOfNumbers1.InsertAt(555, listOfNumbers1.Count);
listOfNumbers1.InsertAt(222, 2);
var arrayVersion = listOfNumbers1.ToArray();
Assert.True(arrayVersion.Length == listOfNumbers1.Count);
/*******************************************************/
var listOfNumbers2 = new SLinkedList <int>();
listOfNumbers2.Append(23);
listOfNumbers2.Append(42);
listOfNumbers2.Append(4);
listOfNumbers2.Append(16);
listOfNumbers2.Append(8);
listOfNumbers2.Append(15);
listOfNumbers2.Append(9);
listOfNumbers2.Append(55);
listOfNumbers2.Append(0);
listOfNumbers2.Append(34);
listOfNumbers2.Append(12);
listOfNumbers2.Append(2);
listOfNumbers2.SelectionSort();
var intArray = listOfNumbers2.ToArray();
foreach (var item in listOfNumbers2)
{
Console.WriteLine(item);
}
Assert.True(intArray[0] == 0 && intArray[intArray.Length - 1] == 55, "Wrong sorting");
}
public void TestIfIncludesCanReturnFalse()
{
SLinkedList newList = new SLinkedList();
newList.Insert(5);
newList.Insert(55);
newList.Insert(50);
Assert.False(newList.Includes(99));
}
public void TestIfIncludesCanReturnTrue()
{
SLinkedList newList = new SLinkedList();
newList.Insert(5);
newList.Insert(15);
newList.Insert(25);
Assert.True(newList.Includes(15));
}
public void TestIfNodeHasMultiInserts()
{
SLinkedList newList = new SLinkedList();
newList.Insert(5);
newList.Insert(10);
newList.Insert(15);
Assert.Equal(15, newList.Head.Value);
}
public void TestCreateLLSeven()
{
//Arrange
Node node1 = new Node(7);
SLinkedList list = new SLinkedList(node1);
//list.Insert();
//Act
bool check = list.Includes(7);
//Assert
Assert.True(check);
}
//Default Accessor Quantifier for methods is private
private static void Main(string[] args)
{
//Creating a SLinkedList
SLinkedList<int> list = new SLinkedList<int>();
for(int i = 0; i < 10000; i++)
{
list.Add(i);
Console.WriteLine(list);
}
}
public void WhereLLIsSizeOf1()
{
//Arrange
Node node1 = new Node(7);
SLinkedList list = new SLinkedList(node1);
//Act
int check = list.ValueAtIndex(0);
//Assert
Assert.Equal(7, check);
}
/// <summary>
/// This simple validation function assumes that data exists in the list
/// in sequential, ascending order e.g. {0,1,2,3,4,5, etc...}
/// </summary>
/// <param name="linklist"></param>
/// <returns></returns>
private static int ValidateListContents(SLinkedList <int> linklist)
{
int count = 0;
var iter = linklist.GetIterator();
while (iter.IsValid())
{
Assert.AreEqual(count++, iter.GetData());
iter.MoveNext();
}
return(count);
}
public void TestInsertTwo()
{
//Arrange
Node node1 = new Node(7);
Node node2 = new Node(2);
SLinkedList list = new SLinkedList(node1);
list.Insert(node2.Data);
//Act
bool check = list.Includes(2);
//Assert
Assert.True(check);
}
static void Main(string[] args)
{
SLinkedList <int> lista = new SLinkedList <int>();
lista.AddFront(3);
lista.AddFront(-1);
lista.AddFront(9);
lista.AddFront(5);
lista.RemoveFront();
lista.RemoveFront();
Console.WriteLine("removed item: {0}", lista.RemoveFront());
Console.WriteLine("size: {0}", lista.size);
Console.ReadLine();
}
public void TestAppendFour()
{
//Arrange
Node node1 = new Node(7);
Node node2 = new Node(2);
Node node3 = new Node(4);
SLinkedList list = new SLinkedList(node1);
list.Insert(node2.Data);
list.Append(node3.Data);
//Act
bool check = list.Includes(4);
//Assert
Assert.True(check);
}
public static void Main()
{
SLinkedList list1 = new SLinkedList();
SLinkedList list2 = new SLinkedList();
list1.Insert(1);
list1.Insert(2);
list1.Insert(3);
list2.Insert(4);
list2.Insert(5);
list2.Insert(6);
MergeList(list1, list2);
//Node resultMerge = MergeList(list1, list2);
//Console.WriteLine(resultMerge.Value);
}
public void MergeTwoLinkedLists()
{
//Arrange
Node node1 = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(3);
Node node4 = new Node(4);
Node node5 = new Node(5);
Node node6 = new Node(6);
Node node7 = new Node(7);
Node node8 = new Node(8);
Node node9 = new Node(9);
Node node10 = new Node(10);
SLinkedList list2 = new SLinkedList(node10);
SLinkedList list1 = new SLinkedList(node9);
SLinkedList list3 = new SLinkedList(node10);
list1.Insert(node7.Data);
list1.Insert(node5.Data);
list1.Insert(node3.Data);
list1.Insert(node1.Data);
list2.Insert(node8.Data);
list2.Insert(node6.Data);
list2.Insert(node4.Data);
list2.Insert(node2.Data);
list3.Insert(node9.Data);
list3.Insert(node8.Data);
list3.Insert(node7.Data);
list3.Insert(node6.Data);
list3.Insert(node5.Data);
list3.Insert(node4.Data);
list3.Insert(node3.Data);
list3.Insert(node2.Data);
list3.Insert(node1.Data);
//Act
SLinkedList check = MergeTwoLL(list1, list2);
int check2 = check.ValueAtIndex(1);
int check3 = list3.ValueAtIndex(1);
//Assert
Assert.Equal(check2, check3);
}
public static void Main(string[] args)
{
var db = new Builder();
var tags = new SLinkedList <string>();
tags.Append("Duro");
tags.Append("Matar");
db.AddMovie(new Common.Movie
{
Category = "Action",
Name = "Duro de matar",
Tags = tags
});
var tags2 = new SLinkedList <string>();
tags2.Append("Agentes");
tags2.Append("Matar");
db.AddMovie(new Common.Movie
{
Category = "Action",
Name = "007",
Tags = tags2
});
var tags3 = new SLinkedList <string>();
tags3.Append("Agentes");
tags3.Append("Matar");
db.AddMovie(new Common.Movie
{
Category = "Action",
Name = "Mision Imposible",
Tags = tags3
});
db.Recomendacion("Action", "007", 1);
//db.SaveDB();
//db.GetDB();
}
public void CanInsertNineAfterSeven()
{
//Arrange
Node node1 = new Node(7);
Node node2 = new Node(2);
Node node3 = new Node(4);
Node node4 = new Node(9);
SLinkedList list = new SLinkedList(node1);
list.Insert(node2.Data);
list.Append(node3.Data);
list.InsertBefore(node4, node1);
//Act
bool check = list.Includes(9);
//Assert
Assert.True(check);
}
public static Node MergeList(SLinkedList list1, SLinkedList list2)
{
Node main = list1.Head;
Node secondary = list2.Head;
while (list1.Head != null && list2.Head != null)
{
Node temp = list1.Current.Next;
list1.Current.Next = list2.Current;
list2.Current = list2.Current.Next;
list1.Current = temp;
if (list1.Current != null)
{
main = secondary.Next;
secondary = main.Next;
}
}
return(list1.Head);
}
public void RequestedIndexOutsideLimit()
{
//Arrange
Node node3 = new Node(4);
Node node5 = new Node(3);
Node node1 = new Node(7);
Node node4 = new Node(9);
Node node2 = new Node(2);
SLinkedList list = new SLinkedList(node1);
list.Insert(node2.Data);
list.Append(node3.Data);
list.InsertBefore(node4, node1);
list.InsertAfter(node5, node1);
//Act
int check = list.ValueAtIndex(6);
//Assert
Assert.Equal(-1, check);
}
public void WhereKIsNegative()
{
//Arrange
Node node3 = new Node(4);
Node node5 = new Node(3);
Node node1 = new Node(7);
Node node4 = new Node(9);
Node node2 = new Node(2);
SLinkedList list = new SLinkedList(node1);
list.Insert(node2.Data);
list.Append(node3.Data);
list.InsertBefore(node4, node1);
list.InsertAfter(node5, node1);
//Act
int check = list.ValueAtIndex(-1);
//Assert
Assert.Equal(-1, check);
}
public void ValueAtIndexTwoIsFour()
{
//Arrange
Node node1 = new Node(7);
Node node2 = new Node(2);
Node node3 = new Node(4);
Node node4 = new Node(9);
Node node5 = new Node(3);
SLinkedList list7 = new SLinkedList(node1);
list7.Insert(node2.Data);
list7.Insert(node3.Data);
list7.Insert(node4.Data);
list7.Insert(node5.Data);
//Act
int check = list7.ValueAtIndex(2);
//Assert
Assert.Equal(4, check);
}
public void SLinkedListMustWork()
{
int n = 1000;
Random rnd = new Random();
SLinkedList <int> mlist = new SLinkedList <int>();
int[] test1 = new int[n];
for (int i = 0; i < n; i++)
{
mlist.PushBack(rnd.Next(-20, 20));
test1[i] = mlist.Trailer.Value;
}
Assert.AreEqual(mlist.Size, n);
Assert.AreEqual(test1[0], mlist.Header.Value);
Assert.AreEqual(test1[n - 1], mlist.Trailer.Value);
var test2 = mlist.ToList();
for (int i = 0; i < n; i++)
{
Assert.AreEqual(test1[i], test2[i]);
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
list = new SLinkedList <string>();
}
public void TestToInstantiateEmptyLinkedList()
{
SLinkedList newList = new SLinkedList();
Assert.Null(newList.Head);
}
static void Main(string[] args)
{
SlinkedListQueue q = new SlinkedListQueue();
q.enqueue(10);
q.enqueue(20);
q.dequeue();
q.dequeue();
q.enqueue(30);
q.enqueue(40);
q.enqueue(50);
var dequedElement = q.dequeue();
Console.WriteLine("Dequeued item is " + dequedElement.key + " " + "and the next item is " + dequedElement.next.key);
BSearchTree tree = new BSearchTree();
/* Let us create following BST
* 50
* / \
* 30 70
* / \ / \
* 20 40 60 80 */
tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(40);
tree.insert(70);
tree.insert(60);
tree.insert(80);
Console.WriteLine("Inorder traversal of the given tree");
tree.inorder();
Console.WriteLine("\nDelete 20");
tree.deleteKey(20);
Console.WriteLine("Inorder traversal of the modified tree");
tree.inorder();
Console.WriteLine("\nDelete 30");
tree.deleteKey(30);
Console.WriteLine("Inorder traversal of the modified tree");
tree.inorder();
Console.WriteLine("\nDelete 50");
tree.deleteKey(50);
Console.WriteLine("Inorder traversal of the modified tree");
tree.inorder();
tree.dispouse();
BSearchTree treeNonRec = new BSearchTree();
/* Let us create following BST
* 50
* / \
* 30 70
* / \ / \
* 20 40 60 80 */
treeNonRec.insertNonRec(50);
treeNonRec.insertNonRec(30);
treeNonRec.insertNonRec(20);
treeNonRec.insertNonRec(40);
treeNonRec.insertNonRec(70);
treeNonRec.insertNonRec(60);
treeNonRec.insertNonRec(80);
Console.WriteLine("Inorder traversal of the given treeNonRec");
treeNonRec.inorder();
Console.WriteLine("\nDelete 20");
treeNonRec.removeNonRec(20);
Console.WriteLine("Inorder traversal of the modified treeNonRec");
treeNonRec.inorder();
Console.WriteLine("\nDelete 30");
treeNonRec.removeNonRec(30);
Console.WriteLine("Inorder traversal of the modified treeNonRec");
tree.inorder();
Console.WriteLine("\nDelete 50");
treeNonRec.RemoveNonRec(50);
Console.WriteLine("Inorder traversal of the modified treeNonRec");
treeNonRec.inorder();
var list = new SLinkedList <int>();
list.Add(1);
list.Add(2);
list.Add(3);
list.Add(4);
list.Add(5);
foreach (var item in list)
{
Console.Write(item + " ");
}
Console.WriteLine();
list.Delete(3);
list.Delete(1);
list.Delete(7);
foreach (var item in list)
{
Console.Write(item + " ");
}
Console.WriteLine();
list.AppendHead(7);
foreach (var item in list)
{
Console.Write(item + " ");
}
Console.WriteLine();
list.InsertAfter(4, 8);
foreach (var item in list)
{
Console.Write(item + " ");
}
Console.WriteLine();
Console.ReadLine();
}
public static void DoTest ()
{
int index = 0;
SLinkedList<int> listOfNumbers1 = new SLinkedList<int>();
listOfNumbers1.Append(10);
listOfNumbers1.Append(124);
listOfNumbers1.Prepend(654);
listOfNumbers1.Prepend(8);
listOfNumbers1.Append(127485693);
listOfNumbers1.Append(34);
listOfNumbers1.Append(823);
Console.WriteLine(listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(0);
Console.WriteLine("Removed 1st:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(3);
listOfNumbers1.RemoveAt(4);
Console.WriteLine("Removed 3rd & 4th:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(2);
Console.WriteLine("Removed 3rd:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(2);
Console.WriteLine("Removed 3rd:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(0);
Console.WriteLine("Remove 1st:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.Prepend(3);
listOfNumbers1.Prepend(2);
listOfNumbers1.Prepend(1);
// Print List and Count
Console.WriteLine(listOfNumbers1.ToReadable());
Console.WriteLine("Count: " + listOfNumbers1.Count + "\r\n");
listOfNumbers1.InsertAt(444, listOfNumbers1.Count);
listOfNumbers1.InsertAt(555, listOfNumbers1.Count);
listOfNumbers1.InsertAt(222, 2);
Console.WriteLine(listOfNumbers1.ToReadable());
Console.WriteLine("Count: " + listOfNumbers1.Count + "\r\n");
index = 0;
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
index = (listOfNumbers1.Count / 2) + 1;
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
index = (listOfNumbers1.Count / 2) + 2;
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
index = (listOfNumbers1.Count - 1);
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
Console.WriteLine();
Console.WriteLine("GetRange(0, 3):\r\n" + listOfNumbers1.GetRange(0, 3).ToReadable());
var arrayVersion = listOfNumbers1.ToArray();
Debug.Assert (arrayVersion.Length == listOfNumbers1.Count);
/************************************************************************************/
var listOfNumbers2 = new SLinkedList<int>();
listOfNumbers2.Append(23);
listOfNumbers2.Append(42);
listOfNumbers2.Append(4);
listOfNumbers2.Append(16);
listOfNumbers2.Append(8);
listOfNumbers2.Append(15);
listOfNumbers2.Append(9);
listOfNumbers2.Append(55);
listOfNumbers2.Append(0);
listOfNumbers2.Append(34);
listOfNumbers2.Append(12);
listOfNumbers2.Append(2);
listOfNumbers2.SelectionSort();
var intArray = listOfNumbers2.ToArray();
Debug.Assert(intArray[0] == 0 && intArray[intArray.Length - 1] == 55, "Wrong sorting!");
}
public static void Main()
{
// Listado de heroes cuyo destino conocemos con cierta certeza
string[] heroes =
{
"Iron Man",
"Captain America",
"The Black Panther",
"Star-Lord",
"Thor",
"Black Widow",
"The Hulk",
"Spider-Man",
"Rocket Raccoon",
"Groot",
"Drax",
"Ant-Man",
"Doctor Stranger",
"The Winter Soldier",
"Scarlet Witch",
"Nebula",
"Falcon",
"War Machine",
"General Okoye",
"M'Baku",
"Mantis",
"Nick Fury",
"Maria Hill",
"Captain Marvel",
"The Wasp",
"Hank Pym",
"Janet van Dyne"
};
// Thanos' Finger Snap: Aleatoriamente decide cuales heroes eliminar
Random rnd = new Random(1234567);
bool[] toRemove = new bool[heroes.Length];
for (int i = 0; i < toRemove.Length; i++)
{
if (rnd.Next(2) == 0)
{
toRemove[i] = true;
}
else
{
toRemove[i] = false;
}
if (toRemove[i])
{
Console.Error.WriteLine(heroes[i]);
}
}
SLinkedList <string> L = new SLinkedList <string>(heroes);
SLinkedList <string> deceased = L.RemoveSelected(toRemove);
Console.WriteLine("Casualties of Thanos' Finger Snap:");
Console.WriteLine(deceased);
Console.WriteLine();
Console.WriteLine("Survivors of Thanos' Finger Snap:");
Console.WriteLine(L);
Console.WriteLine();
Console.ReadLine();
}
/// <summary>
/// Merges two Linked Lists into one Linked List
/// </summary>
/// <param name="list1">First Linked List to be merged</param>
/// <param name="list2">Second Linked List to be merged</param>
/// <returns>Merged Linked List</returns>
public static SLinkedList MergeTwoLL(SLinkedList list1, SLinkedList list2)
{
int length1 = list1.LLLength();
int length2 = list2.LLLength();
if (length2 > length1)
{
list2.Head = list2.Current;
list1.Head = list1.Current;
SLinkedList list = new SLinkedList(list2.Current);
list.Insert(list1.Current.Data);
list2.Current = list2.Current.Next;
list1.Current = list1.Current.Next;
while (list2.Current.Next != null && list1.Current.Next != null)
{
list.Insert(list2.Current.Data);
list.Insert(list1.Current.Data);
list2.Current = list2.Current.Next;
list1.Current = list1.Current.Next;
}
if (list2.Current.Next != null)
{
while (list2.Current.Next != null)
{
list.Insert(list2.Current.Data);
list2.Current = list2.Current.Next;
}
}
list.Insert(list2.Current.Data);
list.Insert(list1.Current.Data);
return(list);
}
else
{
list1.Head = list1.Current;
list2.Head = list2.Current;
SLinkedList list = new SLinkedList(list1.Current);
list.Insert(list1.Current.Data);
list1.Current = list1.Current.Next;
list2.Current = list2.Current.Next;
while (list1.Current.Next != null && list2.Current.Next != null)
{
list.Insert(list1.Current.Data);
list.Insert(list2.Current.Data);
list1.Current = list1.Current.Next;
list2.Current = list2.Current.Next;
}
if (list1.Current.Next != null)
{
while (list1.Current.Next != null)
{
list.Insert(list1.Current.Data);
list1.Current = list1.Current.Next;
}
}
list.Insert(list1.Current.Data);
list.Insert(list2.Current.Data);
return(list);
}
}
public static Node MakeHuffmanTree(HashTable<char, int> frequencyTable)
{
//First, create a singly linked list of nodes to return
SLinkedList<Node> looseNodes = new SLinkedList<Node>();
//we need to loop through the given frequency table
SLinkedList<char> keys = frequencyTable.Keys;
for (int i = 0; i < keys.Size; i++) {
//make new node for each element in hash table
Node n = new Node();
//node Data is current key (keys[i])
n.Data = keys[i];
//node frequency is going to be the value for the current key (table[key])
n.Frequency = frequencyTable[keys[i]];
//add this new node to the end(tail) of the loose nodes list
looseNodes.AddTail(n);
}//end loop
/* Comments, no code */
// Next we need to take this loose collection of nodes and build a tree out of it.
// We do this by combining the smallest value nodes under a parent node. Each iteration
// Of the below loop will reduce size by 1, because it removes two nodes and adds one.
// We know we have a tree built, when the loose nodes list has a size of 1.
/* End comments */
//loop while the looseNodes list has more than one element in it
while (looseNodes.Size > 1) {
//make local variable called left and set it to looseNodes[0]
Node left = looseNodes[0];
//we want to set left to the lowest frequency node, loop through nodes
for (int i = 0; i < looseNodes.Size; i++) {
//if frequency of current node is less than left
if (left.Frequency > looseNodes[i].Frequency) {
//set left to current node
left = looseNodes[i];
}//end if
}//end loop
//now that we have a reference to the smallest node, lets remove it from the list
looseNodes.RemoveAt(looseNodes.IndexOf(left));
//Repeat above steps for a new local node called right
Node right = looseNodes[0];
for (int i = 0; i < looseNodes.Size; i++) {
if (right.Frequency > looseNodes[i].Frequency) {
right = looseNodes[i];
}
}
looseNodes.RemoveAt(looseNodes.IndexOf(right));
//Make a new node
Node n = new Node();
//set its left to the local left node
n.Left = right;
//set its right to the local right node
n.Right = left;
//set its frequency to the sum of the left and right nodes frequencies
n.Frequency = right.Frequency + left.Frequency;
//set its data to '\0' (char equivalent of null)
n.Data = '\0';
//Add the new node to the end of the looseNodes list(AddTail)
looseNodes.AddTail(n);
}//end loop
//at this point the loose node list has only one element, and it's the root node of our huffman table
//return [0] of the loose list
return looseNodes[0];
//end loop ?? what loop
}
public static void DoTest()
{
int index = 0;
SLinkedList <int> listOfNumbers1 = new SLinkedList <int>();
listOfNumbers1.Append(10);
listOfNumbers1.Append(124);
listOfNumbers1.Prepend(654);
listOfNumbers1.Prepend(8);
listOfNumbers1.Append(127485693);
listOfNumbers1.Append(34);
listOfNumbers1.Append(823);
Console.WriteLine(listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(0);
Console.WriteLine("Removed 1st:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(3);
listOfNumbers1.RemoveAt(4);
Console.WriteLine("Removed 3rd & 4th:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(2);
Console.WriteLine("Removed 3rd:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(2);
Console.WriteLine("Removed 3rd:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.RemoveAt(0);
Console.WriteLine("Remove 1st:\r\n" + listOfNumbers1.ToReadable());
listOfNumbers1.Prepend(3);
listOfNumbers1.Prepend(2);
listOfNumbers1.Prepend(1);
// Print List and Count
Console.WriteLine(listOfNumbers1.ToReadable());
Console.WriteLine("Count: " + listOfNumbers1.Count + "\r\n");
listOfNumbers1.InsertAt(444, listOfNumbers1.Count);
listOfNumbers1.InsertAt(555, listOfNumbers1.Count);
listOfNumbers1.InsertAt(222, 2);
Console.WriteLine(listOfNumbers1.ToReadable());
Console.WriteLine("Count: " + listOfNumbers1.Count + "\r\n");
index = 0;
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
index = (listOfNumbers1.Count / 2) + 1;
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
index = (listOfNumbers1.Count / 2) + 2;
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
index = (listOfNumbers1.Count - 1);
Console.WriteLine("Get At " + index + ": " + listOfNumbers1.GetAt(index));
Console.WriteLine();
Console.WriteLine("GetRange(0, 3):\r\n" + listOfNumbers1.GetRange(0, 3).ToReadable());
var arrayVersion = listOfNumbers1.ToArray();
Debug.Assert(arrayVersion.Length == listOfNumbers1.Count);
/************************************************************************************/
var listOfNumbers2 = new SLinkedList <int>();
listOfNumbers2.Append(23);
listOfNumbers2.Append(42);
listOfNumbers2.Append(4);
listOfNumbers2.Append(16);
listOfNumbers2.Append(8);
listOfNumbers2.Append(15);
listOfNumbers2.Append(9);
listOfNumbers2.Append(55);
listOfNumbers2.Append(0);
listOfNumbers2.Append(34);
listOfNumbers2.Append(12);
listOfNumbers2.Append(2);
listOfNumbers2.SelectionSort();
var intArray = listOfNumbers2.ToArray();
Debug.Assert(intArray[0] == 0 && intArray[intArray.Length - 1] == 55, "Wrong sorting!");
}
