public void TestMerge(int expected, int position)
{
// initializes two lists
LList one = new LList(new Node(3));
LList two = new LList(new Node(6));
// add values to the lists
one.Add(new Node(1));
two.Add(new Node(5));
two.Add(new Node(4));
two.Add(new Node(2));
// merges the two lists
LList merged = merge(one, two);
int iterator = 1;
Node nthNode = merged.Head;
// iterates to the nth node
while (iterator < position)
{
nthNode = nthNode.Next;
iterator++;
}
int check = (int)nthNode.Value;
// compares the values
Assert.True(check == expected);
}
static void Main(string[] args)
{
LList ll = new LList(new Node(10));
ll.Add(9);
ll.Add(9);
ll.Add(10);
LList ll2 = new LList(new Node(10));
ll2.Add(9);
ll2.Add(8);
ll2.Add(10);
Console.WriteLine();
Console.WriteLine("First linked list to check for palindrome");
ll.Print();
bool result = CheckPalindrome(ll);
Console.Write("Palindrome: ");
Console.WriteLine(result.ToString());
Console.WriteLine();
Console.WriteLine("Second linked list to check for palindrome");
ll2.Print();
result = CheckPalindrome(ll2);
Console.Write("Palindrome: ");
Console.WriteLine(result.ToString());
Console.ReadLine();
}
public static void Main(string[] args)
{
Node node1 = new Node(7);
Node node2 = new Node("node2");
Node node3 = new Node("node3");
LList List = new LList(node1);
List.Add(node2);
List.Add(node3);
Console.WriteLine("======= Original List =======");
List.Print();
Console.WriteLine("======= Node Appended to the End =======");
Node node4 = new Node("node4");
List.Append(node4);
List.Print();
Console.WriteLine("======= Node Added Before Node 4 =======");
Node node5 = new Node("node5");
List.AddBefore(node5, node4);
List.Print();
Console.WriteLine("======= Node Added After Node 5 =======");
Node node6 = new Node("node6");
List.AddAfter(node6, node5);
List.Print();
Console.WriteLine("======= Find Node with value 7 =======");
//Console.WriteLine(List.FindValue(7));
}
static void Main(string[] args)
{
// Creates new list one with values: [1] -> [3]
LList one = new LList(new Node(3));
one.Add(new Node(1));
// Creates new list two with values: [2] -> [4] -> [5] -> [6]
LList two = new LList(new Node(6));
two.Add(new Node(5));
two.Add(new Node(4));
two.Add(new Node(2));
// Displays the first list
WriteLine("List one has the following values: ");
DisplayList(one);
// Displays the second list
WriteLine("List two has the following values: ");
DisplayList(two);
// Merges the two lists and displays them
LList merged = merge(one, two);
WriteLine("After merging, list should be 1, 2, 3, 4, 5, 6");
WriteLine("Actual");
DisplayList(merged);
}
public void CanGetKthElement(int k, int expectedOutput)
{
LList list = new LList(new Node(1));
list.Add(new Node(3));
list.Add(new Node(8));
list.Add(new Node(2));
Assert.Equal(expectedOutput, Program.ReturnKthToLastNode(list, k).Value);
}
public void CanReverseLLThreeNumbers()
{
LList linkedList = new LList(new Node(3));
linkedList.Add(new Node(9));
linkedList.Add(new Node(4));
Assert.Equal("3 --> 9 --> 4 --> NULL\n", Program.ReverseLL(linkedList).Print());
}
public void AppendTest(int val)
{
LList ll = new LList(new Node(2));
ll.Add(new Node(12));
ll.Add(new Node(13));
ll.Append(new Node(val));
Assert.True((int)ll.Head.Next.Next.Next.Value == val);
}
public void OriginalHeadTest()
{
LList ll = new LList(uno);
ll.Add(dos);
ll.Add(tres);
ll.Add(cuatro);
ll.Add(cinco);
Assert.True((string)ll.Head.Value == "Ovaltine.");
}
public void Search()
{
var list = new LList<int>();
var node = new LNode<int>(6);
list.Add(node);
list.Add(24);
Assert.AreEqual(node, list.Search(6));
}
public void canAddAfter(object valueToAdd, object valueAfter, object[] expectedResult)
{
Node node = new Node(10);
LList ll = new LList(node);
ll.Add(9);
ll.Add(8);
ll.AddAfter(new Node(valueAfter), valueToAdd);
Assert.Equal(expectedResult, ll.ToArray());
}
public void ReturnFalseForAbsentPalindrome()
{
LList ll = new LList(new Node(10));
ll.Add(9);
ll.Add(8);
ll.Add(10);
ll.Print();
Assert.False(Program.CheckPalindrome(ll));
}
public void ReturnTrueForPalindrome()
{
LList ll = new LList(new Node(10));
ll.Add(9);
ll.Add(9);
ll.Add(10);
ll.Print();
Assert.True(Program.CheckPalindrome(ll));
}
static void Main(string[] args)
{
LList list = new LList(new Node(1));
list.Add(new Node(2));
list.Add(new Node(3));
list.Add(new Node(4));
Console.WriteLine("2nd element from the end is: " + Kth_From_End(list, 2).Value);
}
public void Delete()
{
var list = new LList<int>();
var node = new LNode<int>(6);
list.Add(node);
list.Add(24);
Assert.AreEqual(24, list.HeadContent);
}
public void CanReverseLinkedList()
{
LList llToReverse = new LList(new Node(10));
llToReverse.Add(9);
llToReverse.Add(8);
llToReverse.Add(7);
object[] expectedOrder = llToReverse.ToArray();
Array.Reverse(expectedOrder);
Assert.Equal(expectedOrder, Program.Reverse(llToReverse).ToArray());
}
public void ReverseHeadCheckTest()
{
LList ll = new LList(uno);
ll.Add(dos);
ll.Add(tres);
ll.Add(cuatro);
ll.Add(cinco);
LinkedListInReverse(ll);
Assert.True((string)ll.Head.Value == "Be sure");
}
public void ConfirmCorrectSecondNodeInReverseTest()
{
LList ll = new LList(uno);
ll.Add(dos);
ll.Add(tres);
ll.Add(cuatro);
ll.Add(cinco);
LinkedListInReverse(ll);
Assert.True((string)ll.Head.Next.Value == "to");
}
public void Search()
{
var list = new LList <int>();
var node = new LNode <int>(6);
list.Add(node);
list.Add(24);
Assert.AreEqual(node, list.Search(6));
}
public void Delete()
{
var list = new LList <int>();
var node = new LNode <int>(6);
list.Add(node);
list.Add(24);
Assert.AreEqual(24, list.HeadContent);
}
public void AddAfterTest(int val)
{
LList ll = new LList(new Node(100));
ll.Add(new Node(390));
Node nodeToFollow = new Node(1);
ll.Add(nodeToFollow);
ll.AddAfter(new Node(val), nodeToFollow);
Assert.True((int)ll.Head.Next.Value == val);
}
public void CanAddToBeginning(object testValue)
{
Node testNode = new Node("dog");
Node testNode2 = new Node(false);
Node testNode3 = new Node(testValue);
LList testList = new LList(testNode);
testList.Add(testNode2);
testList.Add(testNode3);
Assert.Equal(testValue, testList.Head.Value);
}
public void Add()
{
var list = new LList <int>();
list.Add(new LNode <int>(6));
Assert.AreEqual(6, list.HeadContent);
list.Add(new LNode <int>(5));
Assert.AreEqual(5, list.HeadContent);
list.Add(new LNode <int>(15));
Assert.AreEqual(15, list.HeadContent);
}
public void Add()
{
var list = new LList<int>();
list.Add(new LNode<int>(6));
Assert.AreEqual(6, list.HeadContent);
list.Add(new LNode<int>(5));
Assert.AreEqual(5, list.HeadContent);
list.Add(new LNode<int>(15));
Assert.AreEqual(15, list.HeadContent);
}
public ReverseTest()
{
// adds to the first LL
input.Add(new Node(4));
input.Add(new Node(3));
input.Add(new Node(2));
input.Add(new Node(1));
// adds to thesecond LL
input2.Add(new Node(3));
input2.Add(new Node(5));
input2.Add(new Node(7));
input2.Add(new Node(9));
}
static void Main(string[] args)
{
LList llToReverse = new LList(new Node(10));
llToReverse.Add(9);
llToReverse.Add(8);
llToReverse.Add(7);
Console.WriteLine("Initial linked list to reverse");
llToReverse.Print();
Reverse(llToReverse);
Console.WriteLine();
Console.WriteLine("Reversed linked list");
llToReverse.Print();
Console.ReadLine();
}
public void CanAdd(int value)
{
LList ll = new LList(new Node(1));
ll.Add(new Node(value));
Assert.True((int)ll.Head.Value == value);
}
public void PrintTest(int value)
{
LList list = new LList(new Node(7));
list.Add(new Node(value));
Assert.True(list.Print() == true);
}
public void AddTest(int value)
{
LList list = new LList(new Node(7));
list.Add(new Node(value));
Assert.True((int)list.Head.Value == value);
}
public void AddTest(int val)
{
LList ll = new LList(new Node(1));
ll.Add(new Node(val));
Assert.True((int)ll.Head.Value == val);
}
public void CanConverToArray()
{
Node node = new Node(10);
LList ll = new LList(node);
ll.Add(9);
Assert.Equal(new object[] { 9, 10 }, ll.ToArray());
}
public void TestAddToBeginningOfList(int value)
{
LList testLL = new LList(new Node(6));
Node newNode = new Node(value);
testLL.Add(newNode);
Assert.Equal(value, testLL.Head.Value);
}
public void canAddValues(object valueToAdd, object[] expectedResult)
{
Node node = new Node(10);
LList ll = new LList(node);
ll.Add(valueToAdd);
Assert.Equal(expectedResult, ll.ToArray());
}
public void AddAfterAddsNode(object value)
{
//Arrange
Node node1 = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(3);
Node node4 = new Node(value);
LList list2 = new LList(node1);
list2.Add(node2);
list2.Add(node3);
list2.AddAfter(node4, node2);
//Assert
Assert.True(list2.Includes(value));
}
/// <summary>
///Mthod to add a new vertex with its neighbors.
/// </summary>
/// <param name="vertex"></param>
/// <param name="neighbors"></param>
public void Add(int vertex, IEnumerable<int> neighbors)
{
if (vertex >= _graph.Length)
{
throw new ArgumentOutOfRangeException("vertex not compatible with current graph definition");
}
var linkedList = new LList<int>();
foreach (var neighbor in neighbors)
{
if (neighbor >= _graph.Length)
{
throw new ArgumentOutOfRangeException("vertex not compatible with current graph definition");
}
linkedList.Add(neighbor);
}
_graph[vertex] = linkedList;
}
