MyLinkedList PrepareList()
{
var list = new MyLinkedList();
list.AddNode("3");
list.AddNode("4");
list.AddNode("5");
return(list);
}
public void GetIntersection()
{
var intersectNode1 = new MyLinkedListNode <int>(4);
var intersectNode2 = new MyLinkedListNode <int>(7);
var list1 = new MyLinkedList <int>(new int[] { 7, 1, 6 });
list1.AddNode(intersectNode1);
list1.AddNode(intersectNode2);
var list2 = new MyLinkedList <int>(new int[] { 8, 5, 5, 9, 2 });
list2.AddNode(intersectNode1);
list2.AddNode(intersectNode2);
// Space Complexity: O(1);
// Time Complexity: O(3M + N) ~= O(N);
(int count, MyLinkedListNode <int> last) GetLastNodeAndCount(MyLinkedList <int> list) =>
(list.Count, list.Tail);
var nodeCount_1 = GetLastNodeAndCount(list1);
var nodeCount_2 = GetLastNodeAndCount(list2);
if (nodeCount_1.last != nodeCount_2.last)
{
Assert.True(false);
}
var lists = nodeCount_1.count > nodeCount_2.count
? (major : list1, minor : list2)
: (major : list2, minor : list1);
var aux = lists.major.Count;
var currentMajor = lists.major.Head;
var currentMinor = lists.minor.Head;
while (currentMajor != null && currentMinor != null)
{
if (currentMajor == currentMinor)
{
Assert.Equal(currentMinor, intersectNode1);
break;
}
aux--;
currentMajor = currentMajor.Next;
if (aux < lists.minor.Count)
{
currentMinor = currentMinor.Next;
}
}
Assert.True(false);
}
public void tKthToLast()
{
MyLinkedList<int> list = new MyLinkedList<int>();
list.AddNode(1);
list.AddNode(2);
list.AddNode(3);
list.AddNode(4);
Assert.IsTrue(2 == ReturnKthToLast.KthToLast(2, list));
Assert.IsTrue(4 == ReturnKthToLast.KthToLast(0, list));
Assert.IsTrue(1 == ReturnKthToLast.KthToLast(3, list));
}
public void AddNode_add2Node_outCount2()
{
//arrange
int expected = 2;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(1);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
public void AddNode_NegativeAdd2Node_outCount0()
{
//arrange
int expected = 0;//Предпологаем что отработает не корректно.
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(1);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
static void Main(string[] args)
{
var list = new MyLinkedList();
list.AddNode("3");
list.AddNode("4");
list.AddNode("5");
var worker = new LinkedListWorker();
worker.PrintLinkedList(list);
worker.ReverseList(list);
worker.PrintLinkedList(list);
Console.ReadLine();
}
public void RemoveNode_removeHead_outCount1()
{
//arrange
int expected = 1;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
myList.RemoveNode(1);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
public void FindNode_FindValue2_outValue2()
{
//arrange
int expected = 2;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
Node fNode = myList.FindNode(2);
int actual = fNode.Value;
//assert
Assert.AreEqual <int>(expected, actual);
}
public void GetCount_add3Node_out3()
{
//arrange
int expected = 3;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
myList.AddNode(3);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
public void tPalindrome()
{
MyLinkedList<char> list = new MyLinkedList<char>();
MyLinkedList<char> list2 = new MyLinkedList<char>();
MyLinkedList<char> list3 = new MyLinkedList<char>();
foreach (char c in "neuquen")
{
list.AddNode(c);
}
foreach (char c in "palindrome")
{
list2.AddNode(c);
}
foreach (char c in "BoquitaatiuqoB")
{
list3.AddNode(c);
}
Assert.IsTrue(Palindrome.IsPalindrome(list));
Assert.IsFalse(Palindrome.IsPalindrome(list2));
Assert.IsTrue(Palindrome.IsPalindrome(list3));
}
public void HasLoop()
{
// Arrange...
var list = new MyLinkedList <int>(new int[] { 8, 5, 5, 9, 2, 7, 1 });
var circleNode = list[3];
list.AddNode(circleNode);
// Space Complexity O(N)
// Time Complexity O(N)
var hashTable = new HashSet <int>();
var current = list.Head;
while (current != null)
{
var nodeId = current.GetHashCode();
if (hashTable.Contains(nodeId))
{
Assert.True(true);
break;
}
hashTable.Add(nodeId);
current = current.Next;
}
Assert.True(false);
}
public void ReverseListRecursive_simple()
{
//arrange
var list = new MyLinkedList();
list.AddNode("3");
list.AddNode("4");
var worker = new LinkedListWorker();
//act
worker.ReverseListRecursive(list);
var res = worker.GetString(list);
//assert
Assert.AreEqual("3-4", res);
}
public void Partition()
{
var partition = 5;
var list = new MyLinkedList <int>(new int[] { 3, 5, 8, 5, 10, 2, 1 });
// Time Complexity: O(N)
// Space Complexity: O(1)
var currentNode = list.Head;
list.Clear();
var biggerList = new MyLinkedList <int>();
while (currentNode != null)
{
if (currentNode.Value >= partition)
{
biggerList.AddNode(currentNode.Value);
}
else
{
list.AddNode(currentNode.Value);
}
currentNode = currentNode.Next;
}
list.Tail.Next = biggerList.Head;
}
public void AddNodeAfter_addAfterNode1_outCount3()
{
//arrange
int expected = 3;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
Node fNode = myList.FindNode(1);
myList.AddNodeAfter(fNode, 11);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
public void GetCount_add3NodeandRemove1_out2()
{
//arrange
int expected = 2;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
myList.AddNode(3);
Node fNode = myList.FindNode(1);
myList.RemoveNode(fNode);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
public void AddNodeAfter_addAfterNode1_outNextValue2()
{
//arrange
int expected = 2;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
Node fNode = myList.FindNode(1);
myList.AddNodeAfter(fNode, 11);
fNode = myList.FindNode(11);
int actual = fNode.NextNode.Value;
//assert
Assert.AreEqual <int>(expected, actual);
}
public void tIntersection()
{
MyLinkedList<int> list1 = new MyLinkedList<int>();
MyLinkedList<int> list2 = new MyLinkedList<int>();
Node node = new Node(10);
list1.AddNode(1);
list1.AddNode(4);
list1.AddNode(7);
list1.AddNode(node);
list2.AddNode(3);
list2.AddNode(0);
list2.AddNode(node);
list2.AddNode(6);
Assert.IsTrue(Intersection.Intersect(list1,list2));
}
public void tSumLists()
{
MyLinkedList<char> list1 = new MyLinkedList<char>();
MyLinkedList<char> list2 = new MyLinkedList<char>();
MyLinkedList<char> success = new MyLinkedList<char>();
list1.AddNode('7');
list1.AddNode('1');
list1.AddNode('6');
list2.AddNode('5');
list2.AddNode('9');
list2.AddNode('2');
success.AddNode('2');
success.AddNode('1');
success.AddNode('9');
Assert.IsTrue(SumLists.Sum(list1, list2).CompareList(success));
}
public void RemoveNode_removeOutIndex_outEception()
{
//arrange
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.RemoveNode(2);
//assert
}
public void GetCount_add3NodeRemove1NodeAdd2Node_out4()
{
//arrange
int expected = 4;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
myList.AddNode(2);
myList.AddNode(3);
Node fNode = myList.FindNode(3);
myList.RemoveNode(fNode);
fNode = myList.FindNode(2);
myList.AddNodeAfter(fNode, 21);
myList.AddNodeAfter(fNode, 22);
int actual = myList.GetCount();
//assert
Assert.AreEqual <int>(expected, actual);
}
public void tLoopDetection()
{
MyLinkedList<char> list = new MyLinkedList<char>();
MyLinkedList<char>.Node node;
MyLinkedList<char>.Node repeatedNode = new MyLinkedList<char>.Node('C');
node = new MyLinkedList<char>.Node('A');
list.AddNode(node);
node = new MyLinkedList<char>.Node('B');
list.AddNode(node);
list.AddNode(repeatedNode);
node = new MyLinkedList<char>.Node('D');
list.AddNode(node);
node = new MyLinkedList<char>.Node('E');
list.AddNode(node);
list.AddNode(repeatedNode);
Assert.IsTrue(ReferenceEquals(repeatedNode, LoopDetection.Detect(list)));
list.RemoveNode(6);
Assert.IsTrue(ReferenceEquals(null, LoopDetection.Detect(list)));
}
public void FindNode_FindValue0_outNull()
{
//arrange
Node expected = null;
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
Node actual = myList.FindNode(0);
//assert
Assert.AreEqual <Node>(expected, actual, "Обьект не null");
}
public void AddNodeAfter_addNullNode_outEception()
{
//arrange
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
Node fNode = null;
myList.AddNodeAfter(fNode, 11);
//assert
}
public void tRemoveDups()
{
MyLinkedList<int> list = new MyLinkedList<int>();
list.AddNode(1);
list.AddNode(4);
list.AddNode(5);
list.AddNode(16);
list.AddNode(16);
list.AddNode(4);
list.AddNode(5);
MyLinkedList<int> list2 = new MyLinkedList<int>();
list2.AddNode(1);
list2.AddNode(1);
list2.AddNode(1);
RemoveDups.RemoveDuplicates(list);
RemoveDups.RemoveDuplicates(list2);
Assert.IsTrue(list.Size == 4);
Assert.IsTrue(list2.Size == 1);
}
public void GetString_1()
{
//arrange
var list = new MyLinkedList();
list.AddNode("3");
var worker = new LinkedListWorker();
//act
var st = worker.GetString(list);
//assert
Assert.AreEqual("3", st);
}
public void RemoveNodeByNode_notFoundNode_outEception()
{
//arrange
//actual
MyLinkedList myList = new MyLinkedList();
myList.AddNode(1);
Node fNode = new Node()
{
Value = 2
};
myList.RemoveNode(fNode);
//assert
}
public void HasLoop_Book()
{
// Arrange...
var list = new MyLinkedList <int>(new int[] { 8, 5, 5, 9, 2, 7, 1 });
var circleNode = list[3];
list.AddNode(circleNode);
// Space Complexity O(N)
// Time Complexity O(1)
var slow = list.Head;
var fast = list.Head;
// Find a loop
while (fast.Next != null)
{
slow = slow.Next;
fast = fast.Next.Next;
if (fast == slow)
{
break;
}
}
if (fast.Next == null)
{
Assert.True(false);
}
slow = list.Head;
while (slow != fast)
{
slow = slow.Next;
fast = fast.Next;
}
}
public void tPartition()
{
MyLinkedList<int> list = new MyLinkedList<int>();
list.AddNode(3);
list.AddNode(5);
list.AddNode(8);
list.AddNode(5);
list.AddNode(10);
list.AddNode(2);
list.AddNode(1);
MyLinkedList<int> success = new MyLinkedList<int>();
success.AddNode(3);
success.AddNode(2);
success.AddNode(1);
success.AddNode(5);
success.AddNode(8);
success.AddNode(5);
success.AddNode(10);
Assert.IsTrue(Partition.MakePartition(list, 5).CompareList(success));
}
