static void Main() { //var listNumbers = TakeInput.ListIntPrepare(); //var groupSequence = listNumbers // .GroupBy(x => x) // .OrderBy(x => x.Key) // .ToList(); //foreach (var seq in groupSequence) //{ // Console.WriteLine("{0} => {1} time{2}", // seq.Key, // seq.Count(), // seq.Count() > 1 ? "s" : ""); //} SingleLinkedList<int> linkedList = new SingleLinkedList<int>(); linkedList.Add(2); // 0 linkedList.Add(5); // 1 linkedList.Add(7); // 2 linkedList.Add(7); // 3 linkedList.Add(13); // 4 linkedList.Add(19); // 5 linkedList.Add(21); // 6 linkedList.Add(34); // 7 linkedList.Add(13); // 8 Console.WriteLine(linkedList.LastIndexOf(7)); }
static void MainLinkedList() { var singleLinkedList = new SingleLinkedList<int>(); singleLinkedList.Add(2); singleLinkedList.Add(4); singleLinkedList.Add(6); singleLinkedList.Add(8); singleLinkedList.Add(1); singleLinkedList.Add(3); singleLinkedList.Add(5); singleLinkedList.Add(7); singleLinkedList.Add(9); foreach (var v in singleLinkedList) Console.Write(" {0} ", v); Console.WriteLine(); singleLinkedList.Reverse(); foreach (var v in singleLinkedList) Console.Write(" {0} ", v); Console.WriteLine(); Console.ReadLine(); }
public void InsertTest() { var list = new SingleLinkedList<int>(); for (var i = 0; i < 15; i++) { list.Insert(i); } Assert.Equal(list.Count, 15); }
public void ToListTest() { var list = new SingleLinkedList<int>(); for (var i = 0; i < 15; i++) { list.Insert(i); } var standardList = list.ToList(); Assert.Equal(standardList.Count, list.Count); }
public void AddFirstTest() { var list = new SingleLinkedList<int>(); list.AddFirst(2); list.AddFirst(4); list.AddFirst(6); Assert.AreEqual(list.Head.Value, 6); Assert.AreEqual(list.Tail.Value, 2); }
public void GetTest() { var list = new SingleLinkedList<int>(); for (var i = 0; i < 15; i++) { list.Insert(i); } var node = list.Get(5); Assert.NotNull(node); Assert.Equal(node.Value, 4); }
public void ContainsTest() { var list = new SingleLinkedList<int>(); list.AddLast(2); list.AddLast(4); list.AddLast(6); Assert.AreEqual(list.Contains(2), true); Assert.AreEqual(list.Contains(4), true); Assert.AreEqual(list.Contains(6), true); }
public void RemoveTest() { var list = new SingleLinkedList<int>(); list.AddLast(2); list.AddLast(4); list.AddLast(6); list.Remove(4); Assert.AreEqual(list.Contains(4), false); }
public void head_and_tail_must_have_correct_values() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); list.Add(15); // assert Assert.AreEqual(5, list.First.Value); Assert.AreEqual(15, list.Last.Value); }
public void RemoveLastTest() { var list = new SingleLinkedList<int>(); list.AddLast(2); list.AddLast(4); list.AddLast(6); Assert.AreEqual(list.Tail.Value, 6); list.RemoveLast(); Assert.AreEqual(list.Tail.Value, 4); }
public void contains_does_not_find_value_in_list() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); list.Add(15); list.Add(45); // assert Assert.AreEqual(false, list.Contains(99)); }
static void Main(string[] args) { SingleLinkedList<string> test = new SingleLinkedList<string>(); for (int i = 0; i < 10; i++) { test.Push("test" + i); } test = test.RevertList(); foreach (var n in test ) { Console.WriteLine(n); } Console.ReadKey(); }
public void contains_finds_value_in_list() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); list.Add(15); list.Add(45); // assert Assert.AreEqual(true, list.Contains(5)); Assert.AreEqual(true, list.Contains(15)); Assert.AreEqual(true, list.Contains(45)); }
public void DeleteTest() { var list = new SingleLinkedList<int>(); for (var i = 0; i < 15; i++) { list.Insert(i); } var node = list.Delete(2); Assert.Equal(list.Count, 14); Assert.Equal(node.Value, 1); node = list.Delete(5); Assert.Equal(list.Count, 13); Assert.Equal(node.Value, 5); }
public void add_value_must_be_in_correct_order() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); list.Add(15); list.Add(45); var node = list.First; // assert Assert.AreEqual(5, node.Value); Assert.AreEqual(15, node.Next.Value); Assert.AreEqual(45, node.Next.Next.Value); }
static void Main() { SingleLinkedList<int> test = new SingleLinkedList<int>(); test.Add(5); test.Add(2); test.Add(10); test.Remove(0); test.Add(10); Console.WriteLine(test.LastIndexOf(10)); Console.WriteLine("--" + test.Count); foreach (var i in test) { Console.Write(i + " "); } Console.WriteLine(); }
public void TestGetKthNodeFromLastUsingRunnerTechnique() { var headNode = new SingleLinkedListNode<int>(1); var linkedList = new SingleLinkedList<int>(headNode); var secondNode = new SingleLinkedListNode<int>(2); var thirdNode = new SingleLinkedListNode<int>(3); var fourthNode = new SingleLinkedListNode<int>(4); var fifthNode = new SingleLinkedListNode<int>(5); var sixthNode = new SingleLinkedListNode<int>(6); var seventhNode = new SingleLinkedListNode<int>(7); linkedList.AddToTail(secondNode); linkedList.AddToTail(thirdNode); linkedList.AddToTail(fourthNode); linkedList.AddToTail(fifthNode); linkedList.AddToTail(sixthNode); linkedList.AddToTail(seventhNode); int kthNodeFromLastUsingRunnerTechnique = linkedList.GetKthNodeFromLastUsingRunnerTechnique(5); Assert.AreEqual(3,kthNodeFromLastUsingRunnerTechnique); }
public void TestAddNodeToTail() { var headNode = new SingleLinkedListNode<int>(1); var linkedList = new SingleLinkedList<int>(headNode); var midNode = new SingleLinkedListNode<int>(2); var childNode = new SingleLinkedListNode<int>(3); Assert.AreEqual(1, linkedList.Count); linkedList.AddToTail(midNode); Assert.AreEqual(2, linkedList.Count); linkedList.AddToTail(childNode); Assert.AreEqual(3, linkedList.Count); IEnumerable<int> nodeData = linkedList.GetAllNodeValues().ToList(); Assert.AreEqual(1,nodeData.First()); Assert.AreEqual(2, nodeData.Skip(1).First()); Assert.AreEqual(3, nodeData.Last()); Console.WriteLine(string.Join(",",nodeData.ToArray())); }
public void TestDeleteNode() { var headNode = new SingleLinkedListNode<int>(1); var linkedList = new SingleLinkedList<int>(headNode); var midNode = new SingleLinkedListNode<int>(2); var childNode = new SingleLinkedListNode<int>(3); linkedList.AddToTail(midNode); Assert.AreEqual(2, linkedList.Count); linkedList.AddToTail(childNode); IEnumerable<int> nodeData = linkedList.GetAllNodeValues().ToList(); Assert.AreEqual(1, nodeData.First()); Assert.AreEqual(2, nodeData.Skip(1).First()); Assert.AreEqual(3, nodeData.Last()); SingleLinkedListNode<int> currentLinkedList = linkedList.DeleteNode(2); nodeData = linkedList.GetAllNodeValues().ToList(); Assert.AreEqual(2,nodeData.Count()); Assert.AreEqual(1, nodeData.First()); Assert.AreEqual(3, nodeData.Last()); }
public MyStack() { datas = new SingleLinkedList <T>(); }
//breadth-first fill algorithm, funny note: years ago when I was learning pathfinding I misread the name to be breath-first, hence the name public static void FillBreath(ref BreathArea breath, ref List <ThingController> monstersList, bool cullByTrueDistance = false) { int maxDistance = breath.maxDistance; int arraySize = breath.size; Vec2I StartPoint = breath.position; breath.Invalidate(); if (GetHeat(StartPoint).x == -1) { return; } //init arrays bool[,] closedCheck = new bool[arraySize, arraySize]; bool[,] openCheck = new bool[arraySize, arraySize]; //set start point SingleLinkedList <Vec2I> openList = new SingleLinkedList <Vec2I>(); openList.InsertFront(StartPoint); openCheck[maxDistance, maxDistance] = true; breath.exist[maxDistance, maxDistance] = true; breath.steps[maxDistance, maxDistance] = 0; breath.distance[maxDistance, maxDistance] = 0; breath.direction[maxDistance, maxDistance] = 0; List <ThingController> monsters = new List <ThingController>(); SingleLinkedList <int> randomNeighbors = new SingleLinkedList <int>(); int maxStepDistance = maxDistance * 10; while (openList.Count > 0) { //get top of heap Vec2I current = openList.RemoveHead(); int ax = current.x - StartPoint.x + maxDistance; int ay = current.y - StartPoint.y + maxDistance; int currentDistance = breath.distance[ax, ay]; int currentSteps = breath.steps[ax, ay]; closedCheck[ax, ay] = true; TheGrid.GetNearbyMonsters(current, 0).Perform((n) => { monsters.Add(n.Data); }); if (cullByTrueDistance) { if (currentDistance >= maxStepDistance) { continue; } } Vector3 currentHeat = GetHeat(current); //no propagation through solids if (currentHeat.x >= 1f) { if (current != StartPoint) { continue; } } //don't hassle, shuffle for (int i = 1; i < 9; i++) { if (Random.value > .5f) { randomNeighbors.InsertFront(i); } else { randomNeighbors.InsertBack(i); } } while (randomNeighbors.Count > 0) { int i = randomNeighbors.RemoveHead(); Vec2I neighbor = current + Vec2I.directions[i]; //calculate array position int arrayX = neighbor.x - StartPoint.x + maxDistance; int arrayY = neighbor.y - StartPoint.y + maxDistance; //cull disallowed if (AxMath.RogueDistance(neighbor, StartPoint) > maxDistance) { continue; } if (openCheck[arrayX, arrayY]) { continue; } if (closedCheck[arrayX, arrayY]) { continue; } if (!CanPath(neighbor)) { continue; } openList.InsertBack(neighbor); openCheck[arrayX, arrayY] = true; //reverse direction to point towards the source of breath int p = i + 4; if (p > 8) { p -= 8; } breath.exist[arrayX, arrayY] = true; breath.direction[arrayX, arrayY] = p; breath.distance[arrayX, arrayY] = currentDistance + StepDistance(i); breath.steps[arrayX, arrayY] = currentSteps + 1; } } monstersList = monsters; }
public void SetUp() { _myIntLinkedList = new SingleLinkedList<int>(); //Setting up before every test }
public void remove_one_node_in_list_with_only_one_node() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); // assert Assert.AreEqual(true, list.Remove(5)); Assert.IsNull(list.First); Assert.IsNull(list.Last); }
public SingleLinkedList() { val = 0; next = null; }
public void iterate_through_entire_list_and_yield_results() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); list.Add(10); list.Add(15); var result = ""; foreach (var item in list.Traverse()) { result += item.ToString(); } // assert Assert.AreEqual("51015", result); }
public SingleLinkedList(T value, SingleLinkedList <T> next) { this.Value = value; this.Next = next; }
public void LengthWithZeroItemsTest() { SingleLinkedList <string> single = new SingleLinkedList <string>(); Assert.AreEqual(0, single.lenght); }
public DriverProgram() { singleLL = new SingleLinkedList(); doubleLL = new DoubleLinkedList(); circularLL = new CircularLinkedList(); }
public static void Main(string[] args) { SingleLinkedList <int> list1 = new SingleLinkedList <int>(); for (int i = 0; i < 10; i++) { list1.Add(i + 1); } SingleLinkedList <int> list2 = new SingleLinkedList <int>(list1); list1.AddRange(list2); list1.Show(); Console.WriteLine(); list2.Show(); Console.WriteLine(); Console.WriteLine(Sum(list1)); int[] test = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; String s = toString(test); Console.WriteLine(s); DoubleLinkedList <int> list3 = new DoubleLinkedList <int>(); for (int i = 10; i < 20; i++) { list3.Add(i + 1); } list3.Remove(15); list3.Show(); Console.WriteLine(); Console.WriteLine(list3.IndexOf(12)); DoubleLinkedList <int> list4 = new DoubleLinkedList <int>(list3); list4.Show(); Console.WriteLine(); int[] aa = { 10, 15, 20, 12, 13, 19 }; for (int i = 0; i < aa.Length; i++) { for (int j = i; j < aa.Length; j++) { if (aa[j] < aa[i]) { int temp = aa[i]; aa[i] = aa[j]; aa[j] = temp; } } } for (int i = 0; i < aa.Length; i++) { Console.Write(aa[i].ToString() + ' '); } Console.WriteLine(); Console.WriteLine(); DoubleLinkedList <int> list5 = new DoubleLinkedList <int>(); list5.Add(10); list5.Add(20); list5.Add(15); list5.Add(11); list5.Add(30); list5.Show(); Console.WriteLine(); //InsertSort(list5, 14); Sort(list5); list5.Show(); Console.WriteLine(); //list5.Show(); //Console.WriteLine(); }
public void FindMergePoint() { SingleLinkedList ls = new SingleLinkedList(); ls.MergePoint(); }
public static void LinkedListMenu() { SingleLinkedList myLinkedList = new SingleLinkedList(); int choice; do { Console.Write("\n1. INSERT FRONT\n2. INSERT LAST\n3. DELETE BY KEY\n4. DELETE BY POSITION\n5. DISPLAY\n6. FIND\n7. REVERSE\n8. EXIT TO MENU\nYour choice: "); //pick option while (!int.TryParse(Console.ReadLine(), out choice) || !(choice >= 1 && choice <= 8)) { Console.Write("Type '1' to '8': "); //if wrong, type correct integer } int value; if (choice == 1) //insert at front { Console.Write("Enter value: "); while (!int.TryParse(Console.ReadLine(), out value)) { Console.Write("Type value: "); } Console.ForegroundColor = ConsoleColor.Red; InsertFront(myLinkedList, value); Console.ResetColor(); } if (choice == 2) //insert last { Console.Write("Enter value: "); while (!int.TryParse(Console.ReadLine(), out value)) { Console.Write("Type value: "); } Console.ForegroundColor = ConsoleColor.Red; InsertLast(myLinkedList, value); Console.ResetColor(); } if (choice == 3) //delete by key { Console.Write("Enter value: "); while (!int.TryParse(Console.ReadLine(), out value)) { Console.Write("Type value: "); } Console.ForegroundColor = ConsoleColor.Red; DeleteNodeByKey(myLinkedList, value); Console.ResetColor(); } if (choice == 4) //delete by position { Console.Write("Enter value: "); while (!int.TryParse(Console.ReadLine(), out value)) { Console.Write("Type value: "); } Console.ForegroundColor = ConsoleColor.Red; DeleteNodeByPosition(myLinkedList, value); Console.ResetColor(); } if (choice == 5) //display { Console.ForegroundColor = ConsoleColor.Red; PrintList(myLinkedList); Console.WriteLine(); Console.ResetColor(); } if (choice == 6) //find { Console.Write("Enter value: "); while (!int.TryParse(Console.ReadLine(), out value)) { Console.Write("Type value: "); } Console.ForegroundColor = ConsoleColor.Red; SearchLinkedList(myLinkedList, value); Console.ResetColor(); } if (choice == 7) //reverse { Console.ForegroundColor = ConsoleColor.Red; ReverseLinkedList(myLinkedList); Console.ResetColor(); } } while (choice != 8); //exit to menu }
public LLQueue() { Queue = new SingleLinkedList <T>(); Rear = Queue.Start; }
public void remove_empty_list() { // assemble var list = new SingleLinkedList<int>(); // act // assert Assert.AreEqual(false, list.Remove(99)); Assert.IsNull(list.First); Assert.IsNull(list.Last); }
public void Insert_Some_Elements_Then_Verify_Last() { var list = new SingleLinkedList <string>("The", "Quick", "Brown"); Assert.Equal("Brown", list.First.Next.Next.Value); }
public void remove_node_in_middle_of_list_with_multiple_nodes() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(5); list.Add(10); list.Add(15); // assert Assert.AreEqual(true, list.Remove(10)); Assert.AreEqual(5, list.First.Value); Assert.AreEqual(15, list.Last.Value); Assert.AreEqual(15, list.First.Next.Value); }
public LinkedListQueue() { Items = new SingleLinkedList(); }
public void IsEmptyTest2() { SingleLinkedList <string> single = new SingleLinkedList <string>("item"); Assert.AreEqual(false, single.IsEmpty()); }
public void IsEmptyTest() { SingleLinkedList <string> single = new SingleLinkedList <string>(); Assert.AreEqual(true, single.IsEmpty()); }
public SingleLinkedList(int x) { val = x; next = null; }
public SingleLinkedListBasedQueue() { this._linkedList = new SingleLinkedList <T>(); }
static void DSSingleLinkedListMain(string[] args) { try { SingleLinkedList singleLinkedList = new SingleLinkedList(); Console.WriteLine("Effect of Add First (30,20, 10)"); singleLinkedList.AddFirst(30); singleLinkedList.AddFirst(20); singleLinkedList.AddFirst(10); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Effect of Add Last(40,50)"); singleLinkedList.AddLast(40); singleLinkedList.AddLast(50); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Effect of Add At position(3) value(25)"); singleLinkedList.AddAt(25, 3); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Effect of Remove At Position(3) value(25)"); singleLinkedList.RemoveAt(3); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Effect of Get Kth Node From End( get 3rd node)"); int result = singleLinkedList.GetKthNodeFromEnd(3); Console.WriteLine("3rd node from end is: {0}", result); Console.WriteLine(); Console.WriteLine("Effect of Print Middle Node (when size is odd)"); singleLinkedList.PrintMiddleNode(); Console.WriteLine(); Console.WriteLine("Effect of Print Middle Node (when size is even)"); Console.WriteLine("Adding 1 more node 60 at the end"); singleLinkedList.AddLast(60); singleLinkedList.PrintMiddleNode(); singleLinkedList.RemoveLast(); Console.WriteLine(); Console.WriteLine("Effect of Delete Middle Node (when size is odd)"); singleLinkedList.RemoveMiddleNode(); singleLinkedList.Print(); singleLinkedList.AddAt(30, 3); Console.WriteLine(); Console.WriteLine("Effect of Delete Middle Node (when size is even)"); Console.WriteLine("Adding 1 more node 60 at the end"); singleLinkedList.AddLast(60); singleLinkedList.RemoveMiddleNode(); singleLinkedList.Print(); singleLinkedList.AddAt(30, 3); singleLinkedList.AddAt(40, 4); singleLinkedList.RemoveLast(); Console.WriteLine(); Console.WriteLine("Effect of Remove First(10)"); singleLinkedList.RemoveFirst(); singleLinkedList.Print(); singleLinkedList.AddFirst(10); Console.WriteLine(); Console.WriteLine("Effect of Remove Last(50)"); singleLinkedList.RemoveLast(); singleLinkedList.Print(); singleLinkedList.AddLast(50); Console.WriteLine(); Console.WriteLine("Effect of Remove Even Nodes"); singleLinkedList.RemoveEvenNodes(); singleLinkedList.Print(); singleLinkedList.AddAt(20, 2); singleLinkedList.AddAt(40, 4); Console.WriteLine(); Console.WriteLine("Effect of Remove Odd Nodes"); singleLinkedList.RemoveOddNodes(); singleLinkedList.Print(); singleLinkedList.AddAt(10, 1); singleLinkedList.AddAt(30, 3); singleLinkedList.AddAt(50, 5); Console.WriteLine(); Console.WriteLine("Effect of Remove First Node By Value(30)"); singleLinkedList.RemoveFirstNodeByValue(30); singleLinkedList.Print(); singleLinkedList.AddAt(30, 3); Console.WriteLine(); Console.WriteLine("Effect of Remove Last Node By Value(30)"); singleLinkedList.RemoveLastNodeByValue(30); singleLinkedList.Print(); singleLinkedList.AddAt(30, 3); Console.WriteLine(); Console.WriteLine("Effect of Remove All Nodes By Value(30)"); Console.WriteLine("Adding 3 more 30's in different places"); singleLinkedList.AddAt(30, 5); singleLinkedList.AddAt(30, 2); singleLinkedList.AddAt(30, 1); singleLinkedList.Print(); singleLinkedList.RemoveAllNodesByValue(30); Console.WriteLine("After Remove"); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Effect of Reverse Linked List"); singleLinkedList.Reverse(); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Effect of Remove All"); singleLinkedList.RemoveAll(); singleLinkedList.Print(); Console.WriteLine(); Console.WriteLine("Check the given List has loop or not"); SingleLinkedList list = SingleLinkedList.CreateWithLoop(); Console.WriteLine("Is List is haivng loop: {0}", list.HasLoop()); Console.ReadKey(); Console.ReadKey(); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public StackListDouble() { list = new SingleLinkedList <double>(); }
public void TearDown() { _myIntLinkedList = null; }
public void TestDelete() { // Delete empty var lst = SingleLinkedList <string> .CreateList("the"); lst.Print(); lst.Delete("the"); lst.Print(); try { lst.Delete("the"); } catch (ArgumentException ex) { Assert.IsTrue(ex.Message == "List is empty", "some other error encountered"); } if (lst.IsEmpty) { lst = SingleLinkedList <string> .CreateList("the"); } else { lst.InsertLast("the"); } lst.InsertLast("quick"); lst.InsertLast("brown"); lst.InsertLast("fox"); lst.InsertLast("jumped"); lst.InsertLast("over"); lst.InsertLast("the"); lst.InsertLast("lazy"); lst.InsertLast("dog"); lst.Print(); // delete head var node = lst.Delete("the"); lst.Print(); Assert.IsTrue( node != null && node.Data.Equals("the") && node.Next.Data.Equals("quick"), "Wrong node deleted"); // delete last node = lst.Delete("dog"); lst.Print(); Assert.IsTrue( node != null && node.Data.Equals("dog") && node.Next == null, "Wrong node deleted"); // delete a specific node in mid node = lst.Delete("jumped"); lst.Print(); Assert.IsTrue( node != null && node.Data.Equals("jumped") && node.Next.Data.Equals("over"), "Wrong node deleted"); //delete non-existing node node = lst.Delete("cat"); lst.Print(); Assert.IsTrue(node == null, "Wrong node deleted"); }
public void SingleLinkedListTest(int[] original, int[] expected) { SingleLinkedList sList = new SingleLinkedList(original); Assert.AreEqual(expected, sList.ToArray()); }
/// <summary> /// できるだけ <paramref name="targetLength"/> に近くなるように、使うセクションを決める /// </summary> /// <returns>使用するセクションのインデックス</returns> private static IEnumerable <int> FillRemainingTime(IReadOnlyList <Section> sections, int targetLength, int maxLength) { // インデックス = 時間 // この時間分だけ埋めるときの埋め方を記録 var times = new SingleLinkedList <int> [maxLength + 1]; var sectionCount = sections.Count; for (var sectionIndex = 0; sectionIndex < sectionCount; sectionIndex++) { var sectionLength = sections[sectionIndex].Length; // time に到達する埋め方からつなげるパターン for (var time = 1; ; time++) { var to = time + sectionLength; if (to > maxLength) { break; // length をオーバーするなら終わり } var list = times[time]; if (list != null && // time に到達するルートは存在する list.Value != sectionIndex && // このセクションを含んでいない times[to] == null) // to に到達するルートはまだ見つかっていない { times[to] = new SingleLinkedList <int>(sectionIndex, list); } } // このセクションだけを使った場合 if (sectionLength <= maxLength && times[sectionLength] == null) { times[sectionLength] = new SingleLinkedList <int>(sectionIndex, null); } } // targetLength に一番近い組み合わせを出力 for (var i = 0; ; i++) { var leftTime = targetLength - i; var rightTime = targetLength + i; var canUseLeft = leftTime >= 0; var canUseRight = rightTime <= maxLength; if (!canUseLeft && !canUseRight) { break; } SingleLinkedList <int> list = null; if (canUseLeft) { list = times[leftTime]; } if (list == null && canUseRight) { list = times[rightTime]; } if (list != null) { do { yield return(list.Value); list = list.Next; } while (list != null); break; } } }
public void IsEmptyTest() { var list = new SingleLinkedList <int>(); list.IsEmpty.Should().BeTrue(); }
public void ContainsTest(int[] original, int value, bool expected) { SingleLinkedList sList = new SingleLinkedList(original); Assert.AreEqual(expected, sList.Contains(value)); }
static void Main(string[] args) { SingleLinkedList <string> list1 = new SingleLinkedList <string>(); DoubleLinkedList <string> list = new DoubleLinkedList <string>(); BinarySearchTree <int> searchTree = new BinarySearchTree <int>(); searchTree.Add(10); searchTree.Add(3); searchTree.Add(15); searchTree.Add(2); searchTree.Add(1); Console.WriteLine(searchTree.ToString()); Console.WriteLine(); Console.WriteLine(searchTree.Height()); Console.WriteLine(); Console.WriteLine("Here"); Console.WriteLine(searchTree.InOrder()); Console.WriteLine(); list.Add("A"); list.Add("B"); list.Add("C"); list.Add("D"); list.Add("E"); list.Add("F"); list.Add("G"); list.Add("H"); Console.WriteLine(list.ToString()); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("Deleting index 7"); Console.WriteLine(list.RemoveAt(7)); Console.WriteLine(list.ToString()); Console.WriteLine(); Console.WriteLine("Position 5: " + list.Get(5)); Console.WriteLine(); Console.WriteLine("Deleting node 5"); Console.WriteLine(list.RemoveAt(5)); Console.WriteLine(); Console.WriteLine("Position 5: " + list.Get(5)); Console.WriteLine(); Console.WriteLine(list.ToString()); Console.WriteLine(); Console.WriteLine(list.Search("A")); Console.WriteLine(); list.Insert("X", 0); Console.WriteLine(); Console.WriteLine(list.ToString()); Console.WriteLine(); Console.WriteLine(list.Get(0)); }
public void IndexOfTest(int[] original, int value, int expected) { SingleLinkedList sList = new SingleLinkedList(original); Assert.AreEqual(expected, sList.IndexOf(value)); }
public void Destroy() { datas.Clear(); datas = null; }
public void GetTest(int[] original, int index, int expected) { SingleLinkedList sList = new SingleLinkedList(original); Assert.AreEqual(expected, sList.Get(index)); }
//optimized A* pathfinding public static bool GetPath(Vec2I StartPoint, Vec2I EndPoint, int maxDistance, out Vec2I[] path) { if (StartPoint == EndPoint) { path = new Vec2I[1]; path[0] = EndPoint; return(true); } path = null; if (AxMath.RogueDistance(StartPoint, EndPoint) > maxDistance) { return(false); } if (GetHeat(StartPoint).x == -1) { return(false); } if (GetHeat(EndPoint).x == -1) { return(false); } //init arrays int arraySize = maxDistance * 2 + 1; bool[,] closedCheck = new bool[arraySize, arraySize]; bool[,] openCheck = new bool[arraySize, arraySize]; Vec2I[,] parents = new Vec2I[arraySize, arraySize]; PathStep[,] openArray = new PathStep[arraySize, arraySize]; //set start point BinaryHeap <PathStep> openList = new BinaryHeap <PathStep>(arraySize * arraySize); openList.Add(new PathStep(StartPoint, AxMath.WeightedDistance(StartPoint, EndPoint))); openCheck[maxDistance, maxDistance] = true; parents[maxDistance, maxDistance] = StartPoint; bool found = false; while (openList.ItemCount > 0) { //get top of heap PathStep current = openList.RemoveFirst(); closedCheck[current.position.x - StartPoint.x + maxDistance, current.position.y - StartPoint.y + maxDistance] = true; foreach (Vec2I neighbor in current.position.neighbors) { //calculate array position int arrayX = neighbor.x - StartPoint.x + maxDistance; int arrayY = neighbor.y - StartPoint.y + maxDistance; //cull disallowed if (AxMath.RogueDistance(neighbor, StartPoint) > maxDistance) { continue; } if (closedCheck[arrayX, arrayY]) { continue; } //found target if (neighbor == EndPoint) { parents[arrayX, arrayY] = current.position; found = true; goto finalize; } if (!CanPath(neighbor)) { continue; } //calculate cost int travelCost = current.travelCost + AxMath.WeightedDistance(current.position, neighbor); int heuristic = AxMath.WeightedDistance(neighbor, EndPoint); int fullCost = travelCost + heuristic; //check if we can update parent to better if (openCheck[arrayX, arrayY]) { if (openArray[arrayX, arrayY].travelCost > travelCost) { openArray[arrayX, arrayY].travelCost = travelCost; openArray[arrayX, arrayY].heuristic = heuristic; openArray[arrayX, arrayY].fullCost = fullCost; parents[arrayX, arrayY] = current.position; openList.UpdateItem(openArray[arrayX, arrayY]); continue; } else { continue; } } //priority sorted by heap PathStep step = new PathStep(neighbor, travelCost, heuristic); openList.Add(step); openCheck[arrayX, arrayY] = true; openArray[arrayX, arrayY] = step; parents[arrayX, arrayY] = current.position; } } finalize: if (found) { SingleLinkedList <Vec2I> list = new SingleLinkedList <Vec2I>(); Vec2I current = EndPoint; while (current != StartPoint) { list.InsertFront(current); current = parents[current.x - StartPoint.x + maxDistance, current.y - StartPoint.y + maxDistance]; } //list.InsertFront(current); //adds the starting point to the path path = list.ToArray(); return(true); } return(false); }
public void Setup() { _list = new SingleLinkedList <int>(); }
// tries to make pathfinding more natural like, instead of hugging walls the object tries to move toward corners and doors. public static void NaturalizePath(ref Vec2I[] path, int maxSteps) { if (path.Length < 3) { return; } if (maxSteps < 2) { return; } SingleLinkedList <Vec2I> naturalized = new SingleLinkedList <Vec2I>(); int s = 0; int e = 2; Vec2I[] lastLine = new Vec2I[0]; while (e < path.Length) { int steps = 0; again: Vec2I[] line = AxMath.RogueLine(path[s], path[e]).ToArray(); for (int i = 0; i < line.Length; i++) { if (!CanPath(line[i])) { goto failed; } } if (e < path.Length - 1 && steps <= maxSteps) { lastLine = line; steps++; e++; goto again; } failed: if (e > s + 2) { for (int i = 0; i < lastLine.Length; i++) { naturalized.InsertBack(lastLine[i]); } s = e; e = s + 2; continue; } naturalized.InsertBack(path[s]); s++; e = s + 2; } while (s < path.Length) { naturalized.InsertBack(path[s++]); } path = naturalized.ToArray(); }
public void must_add_node_with_correct_value() { // assemble var list = new SingleLinkedList<int>(); // act list.Add(10); // assert Assert.AreEqual(10, list.First.Value); }