public void TestMethodDoubleLinkedListReverse()
{
ArrayList expected = new ArrayList();
expected.Add(10);
expected.Add(5);
expected.Add(2);
expected.Add(1);
var list = new DoubleLinkedList <int>();
list.AddLast(5);
list.AddLast(10);
list.AddFirst(2);
list.AddFirst(1);
list.Reverse();
ArrayList actual = new ArrayList();
foreach (var item in list)
{
actual.Add(item);
}
CollectionAssert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
try
{
DoubleLinkedList <int> ItemList = new DoubleLinkedList <int>();
ItemList.AddFirst(0);
ItemList.AddLast(6);
ItemList.AddLast(7);
ItemList.AddLast(8);
ItemList.AddLast(9);
ItemList.AddAfter(1, 0);
ItemList.AddAfter(2, 1);
ItemList.AddBefore(5, 6);
ItemList.AddBefore(4, 5);
ItemList.AddBefore(3, 4);
foreach (var item in ItemList)
{
Console.WriteLine(item.ToString());
}
Console.WriteLine(string.Format("Count = {0}", ItemList.Count));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.Read();
}
public void Test1()
{
var list = new DoubleLinkedList <int>();
list.AddLast(10);
list.AddFirst(20);
list.AddFirst(30);
list.AddLast(5);
list.Insert(20, 12);
list.Insert(20, 25, false);
list.Insert(105, 105);
list.Insert(30, 40, false);
list.Contains(105);
list.Contains(30);
list.Contains(40);
list.Contains(400);
list.Insert(20, 12);
list.Insert(12, 400);
//list = list.Reverse();
list.Delete(400);
list.Delete(5);
list.Delete(105);
list.Delete(30);
list.Delete(12);
list.Insert(20, 12);
list.Insert(20, 12);
list.Insert(20, 12);
list.DeleteAll(12);
}
public void AddLastTest(int a, int[] ex)
{
DoubleLinkedList DlList = new DoubleLinkedList();
DlList.AddLast(a);
DlList.AddLast(a);
int[] actual = DlList.ToArray();
Assert.AreEqual(ex, actual);
}
public void TestCountOnAddLastMethod()
{
var linkedList = new DoubleLinkedList<int>();
linkedList.AddLast(3);
linkedList.AddLast(2);
linkedList.AddLast(1);
Assert.AreEqual(3, linkedList.Count);
}
public void TestCountOnAddLastMethod()
{
var linkedList = new DoubleLinkedList <int>();
linkedList.AddLast(3);
linkedList.AddLast(2);
linkedList.AddLast(1);
Assert.AreEqual(3, linkedList.Count);
}
public void FirstOrDefaultTest()
{
IDoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(0);
list.AddLast(1);
list.AddLast(2);
Assert.Equal(list.FirstOrDefault(0, null).Value, 0);
Assert.Equal(list.FirstOrDefault(1, null).Value, 1);
Assert.Equal(list.FirstOrDefault(2, null).Value, 2);
}
public void AddLast_returned_true()
{
int expected = 5;
DoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(1);
list.AddLast(5);
int actual = list.Last.Value;
Assert.AreEqual(expected, actual);
}
public void DisplayForward_ShouldDisplayAllElements_StartFromTheLast()
{
var list = new DoubleLinkedList <int>();
list.AddFirst(2);
list.AddLast(3);
list.AddFirst(1);
list.AddLast(4);
list.AddFirst(0);
Assert.AreEqual("43210", list.DisplayBackward());
}
public void ManyAddAddLast()
{
//Arrange
DoubleLinkedList <int> doubleLinkedList = new DoubleLinkedList <int>();
//Act
doubleLinkedList.AddLast(1);
doubleLinkedList.AddLast(2);
//Assert
Assert.Equal(doubleLinkedList.Last.Value, 2);
Assert.Equal(doubleLinkedList.Last.Prev.Value, 1);
}
public void AddLastTest()
{
IDoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(0);
list.AddLast(1);
list.AddLast(2);
list.AddLast(3);
list.AddLast(4);
CheckListOrder(list);
}
public void FullListContainsTest()
{
DoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(1);
list.AddLast(55);
list.AddFirst(13);
list.AddLast(4);
list.AddFirst(45345);
Assert.IsTrue(list.Contains(4) && list.Contains(1) && list.Contains(55) && list.Contains(13) && list.Contains(4) && list.Contains(45345));
Assert.IsFalse(list.Contains(5));
Assert.IsFalse(list.Contains(37));
}
public void ReverseTest()
{
var list = new DoubleLinkedList <int>();
list.AddLast(1);
list.AddLast(2);
list.AddLast(3);
list.Reverse();
var a = list.ToArray();
var expected = new[] { 3, 2, 1 };
CollectionAssert.AreEqual(expected, a);
}
public void TestFirstMiddleLastElementsOnAddLastMethod()
{
var linkedList = new DoubleLinkedList <int>();
linkedList.AddLast(1);
linkedList.AddLast(2);
linkedList.AddLast(3);
Assert.AreEqual(1, linkedList.First.Value);
Assert.AreEqual(2, linkedList.First.Next.Value);
Assert.AreEqual(3, linkedList.Last.Value);
Assert.AreEqual(3, linkedList.Count);
}
public void TestFindMethodOnExistedElementThatIsPlacedAtTheEnd()
{
var linkedList = new DoubleLinkedList <int>();
linkedList.AddFirst(3);
linkedList.AddFirst(2);
linkedList.AddFirst(1);
linkedList.AddLast(4);
linkedList.AddLast(7);
Assert.IsNotNull(linkedList.Find(4));
Assert.AreEqual(4, linkedList.Find(4).Value);
Assert.AreEqual(5, linkedList.Count);
}
public void CheckDoubleListImplementation()
{
var myList = new DoubleLinkedList <int>();
List <int> netList = new List <int>();
myList.AddLast(1);
foreach (var i in myList)
{
netList.Add(i);
}
LinkedList <int> nwtList = new LinkedList <int>();
Assert.Equal(1, netList[0]);
myList.AddLast(0);
Assert.Equal(1, myList.Head.Value);
Assert.Equal(0, myList.Last.Value);
DoubleLinkedList <int> my3 = new DoubleLinkedList <int>(new[] { 1, 2, 3 });
var node2 = my3.Find(2);
my3.Remove(node2);
netList.Clear();
foreach (var i in my3)
{
netList.Add(i);
}
Assert.Equal(1, netList[0]);
Assert.Equal(3, netList[1]);
my3.Remove(my3.Head);
netList.Clear();
foreach (var i in my3)
{
netList.Add(i);
}
Assert.Equal(3, netList[0]);
var my2List = new DoubleLinkedList <int>(new int[] { 1, 2, 3 });
my2List.Remove(my2List.Find(3));
my2List.Remove(my2List.Find(1));
my2List.Remove(my2List.Find(2));
Assert.Null(my2List.Head);
}
public void AddAfterTest()
{
IDoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(0);
list.AddLast(3);
list.AddAfter(4, 3);
Assert.Throws <ElementNotFoundException <int> >(() => list.AddAfter(-2, 5));
list.AddAfter(1, 0);
list.AddAfter(2, 1);
Assert.Throws <ElementNotFoundException <int> >(() => list.AddAfter(5, 5));
CheckListOrder(list);
}
public void AddBeforeTest()
{
IDoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(1);
list.AddLast(4);
list.AddBefore(3, 4);
Assert.Throws <ElementNotFoundException <int> >(() => list.AddAfter(2, -5));
list.AddBefore(2, 3);
list.AddBefore(0, 1);
Assert.Throws <ElementNotFoundException <int> >(() => list.AddAfter(-2, 5));
CheckListOrder(list);
}
public void IsEmptyTest()
{
IDoubleLinkedList <int> list = new DoubleLinkedList <int>();
Assert.Equal(list.IsEmpty, true);
list.AddFirst(0);
Assert.Equal(list.IsEmpty, false);
list.AddLast(1);
list.AddLast(2);
Assert.Equal(list.IsEmpty, false);
}
public void AddLastTest()
{
DoubleLinkedList <int> dll = new DoubleLinkedList <int>();
dll.AddLast(1);
dll.AddLast(2);
dll.AddLast(3);
int[] ans = new int[] { 1, 2, 3 };
int i = 0;
foreach (var item in dll)
{
Assert.AreEqual(item, ans[i]);
i++;
}
}
public void DoubleLinkedListTest2()
{
//Arrange
int a = -9;
//Act
DoubleLinkedList <int> actual = new DoubleLinkedList <int>();
actual.AddFirst(-9);
actual.AddLast(5);
actual.AddLast(16);
actual.Reverse();
//Assert
Assert.AreEqual(a, actual.Last.Value, "Method is incorrect");
}
public void StringWithNullInsertionSortTest()
{
DoubleLinkedList <string> listStr = new DoubleLinkedList <string>();
listStr = new DoubleLinkedList <string>();
listStr.AddLast("BBB");
listStr.AddLast("aaa");
listStr.AddLast(null);
listStr.AddLast("abc");
listStr.InsertionSortWithDelegate((value1, value2) => string.Compare(value1, value2));
Assert.AreEqual(null, listStr[0]);
Assert.AreEqual("aaa", listStr[1]);
Assert.AreEqual("abc", listStr[2]);
Assert.AreEqual("BBB", listStr[3]);
}
public void Reverse_expected_01234_actual_43210_reverse_returned_true()
{
DoubleLinkedList <int> expected = new DoubleLinkedList <int>();
for (int i = 0; i < 5; i++)
{
expected.AddLast(i);
}
int start_index = 0;
int count = 5;
DoubleLinkedList <int> actual = new DoubleLinkedList <int>();
for (int i = 0; i < 5; i++)
{
actual.AddFirst(i);
}
actual = actual.Reverse(start_index, count);
Assert.AreEqual(expected.Count, actual.Count);
DoubleLinkedListNode <int> source_node = expected.First;
DoubleLinkedListNode <int> reverse_node = actual.First;
while (source_node != null && reverse_node != null)
{
Assert.AreEqual(reverse_node.Value, source_node.Value);
source_node = source_node.Next;
reverse_node = reverse_node.Next;
}
}
public void RemoveLastTest()
{
IDoubleLinkedList <int> list = new DoubleLinkedList <int>();
list.AddLast(0);
list.AddLast(1);
list.AddLast(2);
list.RemoveLast();
Assert.NotEmpty(list);
Assert.DoesNotContain(2, list);
Assert.Contains(0, list);
Assert.Contains(1, list);
Assert.Equal(1, list.Last.Value);
Assert.Equal(0, list.Last.Prev.Value);
}
public void AddLastTest()
{
var list = new DoubleLinkedList <int>();
list.AddFirst(1);
list.AddLast(2);
Assert.AreEqual(2, list.Last());
}
public void OneElement_AddLast_LastShouldBeEqualFirst()
{
var list = new DoubleLinkedList <int>();
list.AddLast(1);
Assert.AreEqual(list.GetFirst(), list.GetLast());
}
public void DoubleLinkedList_AddLast_ReturnsCorrectElement(int value)
{
var list = new DoubleLinkedList <int>();
list.AddLast(1);
Assert.AreEqual(value, list.GetLast());
}
static void Main(string[] args)
{
DoubleLinkedList <string> LIST = new DoubleLinkedList <string>();
// добавление элементов
LIST.AddLast("Katya");
LIST.AddLast("Dasha");
LIST.AddLast("Ivan");
LIST.AddLast("Sveta");
// выводим элементы
foreach (var item in LIST)
{
Console.Write(" " + item);
}
Console.WriteLine();
Console.WriteLine(LIST.Size);
Console.WriteLine("Первый=" + LIST.First());
Console.WriteLine("Последний=" + LIST.Last());
Console.WriteLine("Позиция Dasha: " + LIST.IndexOf("Dasha"));
Console.WriteLine("Позиция Kris: " + LIST.IndexOf("Kris"));
// удаляем элемент
LIST.Remove("Dasha");
foreach (var item in LIST)
{
Console.Write(" " + item);
}
Console.WriteLine();
Console.WriteLine(LIST.Size);
// добавляем элемент в начало
LIST.AddFirst("Liza");
foreach (var item in LIST)
{
Console.Write(" " + item);
}
Console.WriteLine();
Console.WriteLine(LIST.Size);
LIST.Clear();
Console.WriteLine("clear");
Console.WriteLine(LIST.Size);
Console.ReadKey();
}
public void AddLastTest(int[] array, int value, int[] expArray)
{
DoubleLinkedList expected = new DoubleLinkedList(expArray);
DoubleLinkedList actual = new DoubleLinkedList(array);
actual.AddLast(value);
Assert.AreEqual(expected, actual);
}
public void SortDescTest(int[] array, int[] ex)
{
DoubleLinkedList DlList = new DoubleLinkedList();
DlList.AddLast(array);
DlList.Head = DlList.SortDesc(DlList.Head);
int[] actual = DlList.ToArray();
Assert.AreEqual(ex, actual);
}
public void GetSizeTest(int count, int ex)
{
DoubleLinkedList DlListResult = new DoubleLinkedList();
switch (count)
{
case 1:
DoubleLinkedList DlList = new DoubleLinkedList();
for (int i = 0; i < 100000; i++)
{
DlList.AddLast(i);
}
DlListResult = DlList;
break;
case 2:
DoubleLinkedList DlList2 = new DoubleLinkedList();
for (int i = 0; i < 100; i++)
{
DlList2.AddLast(i);
}
DlListResult = DlList2;
break;
case 3:
DoubleLinkedList DlList3 = new DoubleLinkedList();
for (int i = 0; i < 1; i++)
{
DlList3.AddLast(i);
}
DlListResult = DlList3;
break;
case 4:
DoubleLinkedList DlList4 = new DoubleLinkedList();
for (int i = 0; i < 5; i++)
{
DlList4.AddLast(i);
}
DlListResult = DlList4;
break;
case 5:
DoubleLinkedList DlList5 = new DoubleLinkedList();
for (int i = 0; i < 0; i++)
{
DlList5.AddLast(i);
}
DlListResult = DlList5;
break;
}
int actual = DlListResult.GetSize();
Assert.AreEqual(ex, actual);
}
public void TestLastElementOnAddFirstMethod()
{
var linkedList = new DoubleLinkedList<int>();
linkedList.AddLast(1);
Assert.AreEqual(1, linkedList.First.Value);
Assert.AreEqual(1, linkedList.Last.Value);
Assert.AreEqual(1, linkedList.Count);
}
public void TestFirstMiddleLastElementsOnAddLastMethod()
{
var linkedList = new DoubleLinkedList<int>();
linkedList.AddLast(1);
linkedList.AddLast(2);
linkedList.AddLast(3);
Assert.AreEqual(1, linkedList.First.Value);
Assert.AreEqual(2, linkedList.First.Next.Value);
Assert.AreEqual(3, linkedList.Last.Value);
Assert.AreEqual(3, linkedList.Count);
}
/// <summary>
/// Connecting childs to form and store the full path.
/// </summary>
/// <param name="parentNode">The startup Node value.</param>
/// <param name="currentResult">The list stores current paths in every moment.</param>
/// <param name="allPaths">The collection stores all paths.</param>
private void ConnectAllPathsDFS(Node<int> parentNode, DoubleLinkedList<int> currentResult, ref List<DoubleLinkedList<int>> allPaths)
{
currentResult.AddLast(parentNode.Value);
// For each child go and visit its subtree
foreach (var child in parentNode.Childs)
{
this.ConnectAllPathsDFS(child, currentResult, ref allPaths);
}
if (parentNode.Childs.Count == 0)
{
allPaths.Add(new DoubleLinkedList<int>(currentResult));
}
currentResult.RemoveLast();
}
public void TestClearMethod()
{
var linkedList = new DoubleLinkedList<int>();
linkedList.AddFirst(3);
linkedList.AddLast(2);
linkedList.AddAfter(linkedList.First, 1);
linkedList.AddBefore(linkedList.Last, 3);
linkedList.Clear();
Assert.AreEqual(0, linkedList.Count);
Assert.IsNull(linkedList.First);
Assert.IsNull(linkedList.Last);
}
public void TestFindMethodOnExistedElementThatIsPlacedAtTheEnd()
{
var linkedList = new DoubleLinkedList<int>();
linkedList.AddFirst(3);
linkedList.AddFirst(2);
linkedList.AddFirst(1);
linkedList.AddLast(4);
linkedList.AddLast(7);
Assert.IsNotNull(linkedList.Find(4));
Assert.AreEqual(4, linkedList.Find(4).Value);
Assert.AreEqual(5, linkedList.Count);
}
