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);
}
