static void Main(string[] args)
{
MyLinkedList<int> list = new MyLinkedList<int>();
list.AddFirst(5);
list.AddAfter(list.FirstElement, -1);
Console.WriteLine(list);
list.AddFirst(9);
Console.WriteLine(list);
list.Remove(5);
Console.WriteLine(list);
return;
Console.WriteLine();
Console.WriteLine(list);
list.AddLast(10);
Console.WriteLine(list);
list.AddAfter(list.FirstElement, 111);
Console.WriteLine(list);
list.AddAfter(list.FirstElement.NextItem, -100);
Console.WriteLine(list);
list.AddBefore(list.FirstElement.NextItem, 999);
Console.WriteLine(list);
list.AddBefore(list.FirstElement.NextItem.NextItem.NextItem, 800);
Console.WriteLine(list);
}
public void AddAfter_AddsAfter(long index)
{
var itemToAdd = new MyLinkedListNode <string>("added");
_list.AddAfter(itemToAdd, _list[index]);
Assert.AreEqual(itemToAdd, _list[index + 1]);
Assert.AreEqual(_listCount + 1, _list.Count);
Assert.True(FilledListOkay);
}
public void AddAfter_FailsOnNull_OnEmpty()
{
void act()
{
MyLinkedListNode <string> relItem = null;
_emptyList.AddAfter(new MyLinkedListNode <string>("toAdd"), relItem);
}
Assert.Throws <ArgumentNullException>(new TestDelegate(act));
Assert.True(EmptyListOkay);
}
static void Main(string[] args)
{
var myList = new MyLinkedList <string>();
myList.Add("5");
myList.Add("10");
myList.AddAfter("5", "100");
myList.AddAfter("100", "5");
myList.AddAfter("10", "last");
myList.Add("really last");
myList.Print();
}
public void TestAddAfter()
{
string[] values = { "a", "b", "c", "d", "e" };
MyLinkedList <string> l = new MyLinkedList <string>(values);
l.AddAfter(l.First, "w");
bool result = l.First.Next.Value == "w";
Assert.AreEqual(true, result);
}
public void AddAfter_AddAfterLastElement_Added()
{
//Arrange
var testList = new MyLinkedList <int>();
testList.Add(22);
testList.Add(44);
//Act
testList.AddAfter(44, 55);
}
public void AddAfter_ElementNotExist_InvalidOperationException()
{
//Arrange
var testList = new MyLinkedList <int>();
testList.Add(22);
testList.Add(44);
//Act
testList.AddAfter(33, 55);
}
public void AddAfterTest()
{
MyLinkedList <string> list = new MyLinkedList <string>();
CollectionAssert.AreEqual(new string[] { }, list);
var node = list.AddLast("abs");
CollectionAssert.AreEqual(new string[] { "abs" }, list);
list.AddAfter(node, "zz");
CollectionAssert.AreEqual(new string[] { "abs", "zz" }, list);
}
static void Main()
{
Console.WriteLine("Dot Net LinkedList");
LinkedList<int> dotNetList = new LinkedList<int>();
dotNetList.AddFirst(3);
dotNetList.AddFirst(1);
dotNetList.AddBefore(dotNetList.Last, 2);
dotNetList.AddBefore(dotNetList.First, 4);
dotNetList.AddAfter(dotNetList.Last, 5);
dotNetList.AddAfter(dotNetList.First, 6);
dotNetList.AddLast(7);
dotNetList.AddLast(8);
dotNetList.RemoveFirst();
dotNetList.RemoveLast();
foreach (var item in dotNetList)
{
Console.WriteLine(item);
}
Console.WriteLine("Dot Net LinkedList.Count = {0}", dotNetList.Count);
Console.WriteLine();
Console.WriteLine("My LinkedList<T>");
MyLinkedList<int> myList = new MyLinkedList<int>();
myList.AddFirst(3);
myList.AddFirst(1);
myList.AddBefore(myList.Last, 2);
myList.AddBefore(myList.First, 4);
myList.AddAfter(myList.Last, 5);
myList.AddAfter(myList.First, 6);
myList.AddLast(7);
myList.AddLast(8);
myList.RemoveFirst();
myList.RemoveLast();
foreach (var number in myList)
{
Console.WriteLine(number);
}
Console.WriteLine("MyList.Count = {0}", myList.Count);
}
public void AddAfter_Add3After5_NextAfter3Equal5()
{
MyLinkedList <int> myList = new MyLinkedList <int>()
{
1, 2, 3, 4, 5
};
myList.AddAfter(3, 5);
CollectionAssert.Contains(myList, 5, "List should contain element {0}", 5);
Assert.AreEqual(5, myList[3], "Element after 3 is not 5");
}
public void AddAfterCanAddLast()
{
//Arrange
Node firstNode = new Node(1);
Node secondNode = new Node(2);
MyLinkedList list1 = new MyLinkedList(firstNode);
//Act
list1.AddAfter(secondNode, firstNode);
Node found = list1.KthElement(0);
//Assert
Assert.Equal(secondNode, found);
}
public void AddAfter_ElementExist_Ok()
{
//Arrange
var testList = new MyLinkedList <int>();
testList.Add(33);
testList.Add(44);
//Act
testList.AddAfter(33, 55);
//Assert
Assert.AreEqual("33;55;44;", testList.ToString());
}
private void ArrangeAndActUponLinkedLists(LinkedList <int> originalLinkedList, MyLinkedList <int> myLinkedList)
{
LinkedListNode <int> fiveHundredListNode = new LinkedListNode <int>(500);
LinkedListNode <int> tenListNode = new LinkedListNode <int>(10);
LinkedListNode <int> last = new LinkedListNode <int>(666);
MyLinkedListNode <int> myFiveHundredListNode = new MyLinkedListNode <int>(500);
MyLinkedListNode <int> myTenListNode = new MyLinkedListNode <int>(10);
MyLinkedListNode <int> myLast = new MyLinkedListNode <int>(666);
originalLinkedList.AddFirst(tenListNode);
originalLinkedList.AddBefore(tenListNode, 9);
originalLinkedList.AddAfter(tenListNode, fiveHundredListNode);
originalLinkedList.AddLast(last);
originalLinkedList.Remove(10);
originalLinkedList.AddAfter(last, 777);
originalLinkedList.Remove(fiveHundredListNode);
originalLinkedList.RemoveFirst();
originalLinkedList.RemoveLast();
originalLinkedList.Clear();
originalLinkedList.AddLast(5);
originalLinkedList.RemoveFirst();
myLinkedList.AddFirst(myTenListNode);
myLinkedList.AddBefore(myTenListNode, 9);
myLinkedList.AddAfter(myTenListNode, myFiveHundredListNode);
myLinkedList.AddLast(myLast);
myLinkedList.Remove(10);
myLinkedList.AddAfter(myLast, 777);
myLinkedList.Remove(myFiveHundredListNode);
myLinkedList.RemoveFirst();
myLinkedList.RemoveLast();
myLinkedList.Clear();
myLinkedList.AddLast(5);
myLinkedList.RemoveFirst();
}
public void AddAfterDoesNothingIfExistingNodeDoesNotExist()
{
//Arrange
Node firstNode = new Node(1);
Node secondNode = new Node(2);
Node thirdNode = new Node(3);
MyLinkedList list1 = new MyLinkedList(firstNode);
//Act
list1.AddAfter(thirdNode, secondNode);
Node found = list1.KthElement(0);
//Assert
Assert.NotEqual(found, thirdNode);
Assert.Equal(found, firstNode);
}
public void TestAddAfterNull()
{
string[] values = { "a", "b", "c", "d", "e" };
MyLinkedList <string> l = new MyLinkedList <string>(values);
bool result = true;
try
{
l.AddAfter(null, "a");
}
catch
{
result = false;
}
Assert.AreEqual(false, result);
}
public void TestAddAfterExisting()
{
string[] values = { "a", "b", "c", "d", "e" };
MyLinkedList <string> l = new MyLinkedList <string>(values);
bool result = true;
try
{
l.AddAfter(l.First, l.Last);
}
catch
{
result = false;
}
Assert.AreEqual(false, result);
}
public void TestAddAfterDoesnotBelong()
{
string[] values = { "a", "b", "c", "d", "e" };
MyLinkedList <string> l = new MyLinkedList <string>(values);
MyLinkedListNode <string> n = new MyLinkedListNode <string>();
bool result = true;
try
{
l.AddAfter(n, "a");
}
catch
{
result = false;
}
Assert.AreEqual(false, result);
}
public static MyLinkedList <Fraction> GetRowOfFarey(int n)
{
var rowOfFarey = new MyLinkedList <Fraction>();
rowOfFarey.Add(new Fraction(0, 1));
rowOfFarey.Add(new Fraction(1, 1));
int c = 1;
while (c < n)
{
Node <Fraction> currentNode = rowOfFarey.head;
while (currentNode.Next != null)
{
if (currentNode.Value.denominator + currentNode.Next.Value.denominator < c + 2)
{
rowOfFarey.AddAfter(currentNode, currentNode.Value + currentNode.Next.Value);
}
currentNode = currentNode.Next;
}
c++;
}
return(rowOfFarey);
}
static void TestSinglyLinkedList()
{
Console.WriteLine(" ***** Singly Linked List Implementation ***** ");
MyLinkedList <int> testList = new MyLinkedList <int>();
//testing AddFirst
for (int i = 0; i < 6; i++)
{
testList.AddFirst(i);
}
CollectionToString CtoS = new CollectionToString();
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test reverse
testList.Reverse();
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test AddLast
testList.AddLast(7);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test AddAfter
//after head
testList.AddAfter(5, 6);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//in middle
testList.AddAfter(4, 5);
//after end
testList.AddAfter(7, 8);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//handle miss
testList.AddAfter(9, 3);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test AddBefore
//before head
testList.AddBefore(5, 4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//in middle
testList.AddBefore(3, 4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//before last
testList.AddBefore(8, 7);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//handle miss
testList.AddBefore(9, 3);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test DeleteAt
//first
testList.DeleteAt(4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//middle
testList.DeleteAt(4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//end
testList.DeleteAt(8);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//handle miss
testList.DeleteAt(9);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
}
