static void Opgave2()
{
System.Console.WriteLine("\n===== Opgave 2 : MyLinkedList =====\n");
MyLinkedList <string> ll = new MyLinkedList <string>();
System.Console.WriteLine(ll);
ll.AddFirst("a");
ll.AddFirst("b");
ll.AddFirst("c");
ll.Insert(2, "x");
System.Console.WriteLine(ll);
try
{
ll.Insert(4, "kan niet");
}
catch (MyLinkedListIndexOutOfRangeException e)
{
System.Console.WriteLine(e.Message);
}
ll.Clear();
ll.AddFirst("a");
ll.AddFirst("b");
System.Console.WriteLine(ll.GetFirst());
ll.RemoveFirst();
System.Console.WriteLine(ll);
ll.RemoveFirst();
System.Console.WriteLine(ll);
}
static void Main(string[] args)
{
MyLinkedList<int> list = new MyLinkedList<int>();
list.AddFirst(5);
list.AddAfter(list.FirstElement, -1);
Console.WriteLine(list);
list.AddFirst(9);
Console.WriteLine(list);
list.Remove(5);
Console.WriteLine(list);
return;
Console.WriteLine();
Console.WriteLine(list);
list.AddLast(10);
Console.WriteLine(list);
list.AddAfter(list.FirstElement, 111);
Console.WriteLine(list);
list.AddAfter(list.FirstElement.NextItem, -100);
Console.WriteLine(list);
list.AddBefore(list.FirstElement.NextItem, 999);
Console.WriteLine(list);
list.AddBefore(list.FirstElement.NextItem.NextItem.NextItem, 800);
Console.WriteLine(list);
}
public static void Main()
{
MyLinkedList <int> s = new MyLinkedList <int>();
s.AddFirst(10);
s.AddFirst(20);
s.AddFirst(30);
s.AddFirst(40);
}
static void Main(string[] args)
{
MyLinkedList <int> linkedList = new MyLinkedList <int>();
linkedList.AddFirst(1);
linkedList.AddFirst(2);
linkedList.AddLast(3);
linkedList.RemoveFirst();
}
public void AddFirstTest()
{
MyLinkedList <string> list = new MyLinkedList <string>();
CollectionAssert.AreEqual(new string[] { }, list);
list.AddFirst("abs");
CollectionAssert.AreEqual(new string[] { "abs" }, list);
list.AddFirst("zzz");
CollectionAssert.AreEqual(new string[] { "zzz", "abs" }, list);
list.AddFirst("ыыыы");
CollectionAssert.AreEqual(new string[] { "ыыыы", "zzz", "abs" }, list);
}
static void Main(string[] args)
{
var ll = new MyLinkedList<int>();
ll.AddFirst(1);
ll.AddFirst(2);
ll.AddFirst(3);
ll.AddFirst(4);
ll.AddFirst(5);
foreach (var link in ll)
{
Console.WriteLine(link);
}
}
public static void Main(string[] args)
{
MyLinkedList list = new MyLinkedList();
list.AddFirst("Hello");
list.AddLast("world");
list.AddLast("!");
list.AddLast("!");
list.AddLast("!");
list.AddLast("!");
list.RemoveByIndex(0);
list.AddFirst("Hi");
// check = true
var check = list.RemoveEveryEqual("!");
var array = list.ToArray();
// Hi
// world
foreach (var @object in array)
{
Console.WriteLine(@object);
}
// -1
Console.WriteLine(list.IndexOf("Bob"));
// 0
Console.WriteLine(list.IndexOf("Hi"));
// 1
Console.WriteLine(list.IndexOf("world"));
list[1] = "beautiful";
array = list.ToArray();
// Hi
// beautiful
// world
foreach (var @object in array)
{
Console.WriteLine(@object);
}
}
static void Main(string[] args)
{
MyLinkedList<string> list = new MyLinkedList<string>();
list.AddLast("pesho");
list.AddLast("gosho");
list.AddLast("anna");
list.Add(1, "mariq");
list.AddFirst("ala bala");
foreach (var item in list)
{
Console.WriteLine(item);
}
Console.WriteLine();
list.Remove("anna");
list.RemoveFirst();
list.RemoveLast();
foreach (var item in list)
{
Console.WriteLine(item);
}
Console.WriteLine();
list.Clear();
Console.WriteLine(list.Count);
}
public void Add(T e)
{
if (!list.Contains(e))
{
list.AddFirst(e);
}
}
public static List<Node> PossibleNode = new List<Node>(); // Les noeuds possibles (cases adjacentes de tout le chemin)
#endregion Fields
#region Methods
public static MyLinkedList<Tile> CalculatePathWithAStar(Map map, Tile startTile, Tile endTile)
{
PossibleNode.Clear();
NodeList<Node> openList = new NodeList<Node>(); // Contiens tout les noeuds candidat (qui vont être examinés)
NodeList<Node> closedList = new NodeList<Node>(); // Contiens la liste des meilleurs noeuds (le resultat du plus cours chemin)
List<Node> possibleNodes; // cases adjacentes du noeud courant
// Le noeud de départ
Node startNode = new Node(startTile, null, endTile); // FIXME : on recupère le noeud de départ
/**********************************/
/* Traitement des noeuds candidat */
/**********************************/
openList.Add(startNode);
while (openList.Count > 0) // Tant que la liste ouverte contient des éléments
{
Node current = openList[0];
openList.RemoveAt(0);
closedList.Add(current);
if (current.Tile == endTile) // si l'élément courant est la case destination
{
MyLinkedList<Tile> solution = new MyLinkedList<Tile>();
// on reverse la liste fermée et on la retourne pour l'avoir dans le bonne ordre
while (current.Parent != null)
{
solution.AddFirst(current.Tile);
current = current.Parent;
}
return solution;
}
possibleNodes = current.GetPossibleNode(map, endTile); // FIXME : recupère la listes des cases adjacentes
// on ajoute cette liste a notre variable static qui contient l'ensemble des listes adjacentes (gestion de l'affichage)
PossibleNode.AddRange(possibleNodes) ;
/***************************************/
/* Ajout des noeuds adjacents candidat */
/***************************************/
for (int i = 0; i < possibleNodes.Count; i++) // on vérifie que chaque noeuds adjacent (possibleNodes)
{
if (!closedList.Contains(possibleNodes[i])) // n'existe pas dans la liste fermée (eviter la redondance)
{
if (openList.Contains(possibleNodes[i])) // FIXME : Si il existe dans la liste ouverte on vérifie
{
if (possibleNodes[i].EstimatedMovement < openList[possibleNodes[i]].EstimatedMovement) // si le cout de deplacement du
// noeud est inferieur a un coût calculer précedement, dance cas la on remonte le chemin dans la liste ouverte
openList[possibleNodes[i]].Parent = current;
}
else
openList.DichotomicInsertion(possibleNodes[i]);
}
}
}
return null;
}
public void TestAddition()
{
//Assign
MyLinkedList <int> list = new MyLinkedList <int>();
int value = 5;
//Act
var node = list.AddFirst(value);
list.AddFirst(2);
list.AddFirst(3);
list.AddFirst(4);
//Assert
Assert.AreEqual(value, node.Data);
Assert.AreEqual(4, list.Count);
Assert.AreEqual(true, list.Contains(3));
}
public void TestAddFirstToEmpty()
{
MyLinkedList l = new MyLinkedList();
l.AddFirst(0, -9);
bool result = l.First.I == 0 && l.Count == 1;
Assert.AreEqual(true, result);
}
public void FirstAndLastEqualsTest()
{
MyLinkedList <string> list = new MyLinkedList <string>();
list.AddLast("abs");
Assert.AreEqual(list.Last, list.First);
list.Clear();
list.AddFirst("aaffa");
Assert.AreEqual(list.First, list.Last);
}
public void AddLatest(TCmd cmd)
{
if (_logger.IsDebugEnabled)
{
//_logger.DebugFormat("Cmd List Added {0}", cmd);
}
_userCmdList.AddFirst(cmd);
cmd.AcquireReference();
Trunc();
}
public void MyLinkedList_NotEquals_OriginalLinkedList()
{
LinkedList <int> originalLinkedList = _linkedListService.CreateLinkedList(new LinkedList <int>()) as LinkedList <int>;
MyLinkedList <int> myLinkedList = _linkedListService.CreateLinkedList(new MyLinkedList <int>()) as MyLinkedList <int>;
ArrangeAndActUponLinkedLists(originalLinkedList, myLinkedList);
myLinkedList.AddFirst(1);
Assert.NotEqual(myLinkedList, originalLinkedList);
}
public static void Main()
{
MyLinkedList <int> s = new MyLinkedList <int>();
s.AddFirst(10);
s.AddFirst(20);
s.AddFirst(30);
s.AddFirst(40);
Console.WriteLine("1 Before Call GetEnumerator");
IEnumerator <int> it = s.GetEnumerator(); // 실제 호출 안됨.
Console.WriteLine("2 After Call GetEnumerator");
while (it.MoveNext())
{
Console.WriteLine("4. After MoveNext");
Console.WriteLine(it.Current);
}
}
static void Main()
{
Console.WriteLine("Dot Net LinkedList");
LinkedList<int> dotNetList = new LinkedList<int>();
dotNetList.AddFirst(3);
dotNetList.AddFirst(1);
dotNetList.AddBefore(dotNetList.Last, 2);
dotNetList.AddBefore(dotNetList.First, 4);
dotNetList.AddAfter(dotNetList.Last, 5);
dotNetList.AddAfter(dotNetList.First, 6);
dotNetList.AddLast(7);
dotNetList.AddLast(8);
dotNetList.RemoveFirst();
dotNetList.RemoveLast();
foreach (var item in dotNetList)
{
Console.WriteLine(item);
}
Console.WriteLine("Dot Net LinkedList.Count = {0}", dotNetList.Count);
Console.WriteLine();
Console.WriteLine("My LinkedList<T>");
MyLinkedList<int> myList = new MyLinkedList<int>();
myList.AddFirst(3);
myList.AddFirst(1);
myList.AddBefore(myList.Last, 2);
myList.AddBefore(myList.First, 4);
myList.AddAfter(myList.Last, 5);
myList.AddAfter(myList.First, 6);
myList.AddLast(7);
myList.AddLast(8);
myList.RemoveFirst();
myList.RemoveLast();
foreach (var number in myList)
{
Console.WriteLine(number);
}
Console.WriteLine("MyList.Count = {0}", myList.Count);
}
private static MyLinkedList <MovementTile> CreatePath(MovementTile finish)
{
MyLinkedList <MovementTile> path = new MyLinkedList <MovementTile> ();
while (finish != null)
{
path.AddFirst(finish);
finish = finish.prev;
}
return(path);
}
static void LinkedList()
{
System.Console.WriteLine("\n===== MyLinkedList =====\n");
IMyLinkedList <string> lst = DSBuilder.CreateMyLinkedList();
lst.AddFirst("1");
lst.AddFirst("2");
lst.AddFirst("3");
lst.Insert(0, "0");
Console.WriteLine(lst.ToString());
MyLinkedList <string> ll = new MyLinkedList <string>();
System.Console.WriteLine(ll);
ll.AddFirst("a");
ll.AddFirst("b");
ll.AddFirst("c");
ll.Insert(2, "x");
System.Console.WriteLine(ll);
try
{
ll.Insert(4, "kan niet");
}
catch (MyLinkedListIndexOutOfRangeException e)
{
System.Console.WriteLine(e.Message);
}
ll.Clear();
ll.AddFirst("a");
ll.AddFirst("b");
System.Console.WriteLine(ll.GetFirst());
ll.RemoveFirst();
System.Console.WriteLine(ll);
ll.RemoveFirst();
System.Console.WriteLine(ll);
}
private MyLinkedList <int> ListSetUp()
{
MyLinkedList <int> list = new MyLinkedList <int>();
list.AddFirst(1); list.AddFirst(5); list.AddFirst(7);
list.AddFirst(3); list.AddFirst(2); list.AddFirst(10);
return(list);
}
public void TestAddContains()
{
//Assign
MyLinkedList <int> list = new MyLinkedList <int>();
//Act
list.AddLast(2);
list.AddLast(3);
list.AddLast(4);
list.AddFirst(8);
//Assert
Assert.AreEqual(true, list.Contains(3));
Assert.AreEqual(4, list.Count());
Assert.AreEqual(true, list.Contains(8));
}
public void TestAddString()
{
//Assign
MyLinkedList <string> list = new MyLinkedList <string>();
//Act
list.AddLast("2");
list.AddLast("pootIs");
list.AddLast("åäö");
list.AddFirst("8");
//Assert
Assert.AreEqual(true, list.Contains("åäö"));
Assert.AreEqual(4, list.Count());
Assert.AreEqual(true, list.Contains("8"));
Assert.AreEqual(true, list.Contains("pootIs"));
}
public void TestIndexing()
{
//Assign
MyLinkedList <int> list = new MyLinkedList <int>();
list.AddFirst(1);
var node = list.AddLast(2);
//Act
var testCurrent = list.Get(2);
list.Clear();
var testNull = list.Get(1);
//Assert
Assert.AreEqual(testCurrent, node);
Assert.IsNull(testNull);
}
public static MyLinkedList <T> Reverse <T>(this MyLinkedList <T> list)
{
if (list == null)
{
return(null);
}
var initialFirstNode = list.FirstNode;
var node = list.FirstNode;
while (node.Next != null)
{
node = list.RemoveNextNode(node);
list.AddFirst(node); // current node != null because it entered the while loop
node = initialFirstNode;
}
return(list);
}
public void Update(GameTime gameTime)
{
msElapsed += gameTime.ElapsedGameTime.Milliseconds;
if (walkingList.Size != 0)
{
if (msElapsed >= 100)
{
// on met a jour la position du héros
X = walkingList.Head.Data.X;
Y = walkingList.Head.Data.Y;
Position = walkingList.Head.Data.Position;
// on conserve ses déplacements dans la liste lastpath
lastpath.AddFirst(walkingList.Head.Data);
// on supprime la case où l'on vient d'avancer pour rappeler sur la suivante.
walkingList.RemoveFirst(walkingList.Head.Data);
msElapsed = 0;
}
}
}
public void TestAddLast()
{
var expected = "foo";
var inputs = new string[] { "node0", "node1", "node2", "node3" };
var items = new MyLinkedList <string>();
for (var i = 0; i < inputs.Length; i++)
{
if (i == 2)
{
items.AddLast("foo");
}
items.AddFirst(inputs[i]);
}
;
var actual = items.Last.Value;
Assert.AreEqual(expected, actual);
PrintItemValues(items);
}
public MyLinkedList Organize(MyLinkedList list, int partition)
{
MyLinkedList left = new MyLinkedList();
MyLinkedList right = new MyLinkedList();
MyNode current = list.First;
while (current.Next != null)
{
if (current.Value < partition)
{
if (left.Count == 0)
{
left.AddFirst(current);
}
else
{
left.AddLast(current);
}
}
else
{
if (right.Count == 0)
{
right.AddFirst(current);
}
else
{
right.AddLast(current);
}
}
current = current.Next;
}
MyLinkedList result = new MyLinkedList(left);
result.Last.Next = right.First;
return(result);
}
private void ArrangeAndActUponLinkedLists(LinkedList <int> originalLinkedList, MyLinkedList <int> myLinkedList)
{
LinkedListNode <int> fiveHundredListNode = new LinkedListNode <int>(500);
LinkedListNode <int> tenListNode = new LinkedListNode <int>(10);
LinkedListNode <int> last = new LinkedListNode <int>(666);
MyLinkedListNode <int> myFiveHundredListNode = new MyLinkedListNode <int>(500);
MyLinkedListNode <int> myTenListNode = new MyLinkedListNode <int>(10);
MyLinkedListNode <int> myLast = new MyLinkedListNode <int>(666);
originalLinkedList.AddFirst(tenListNode);
originalLinkedList.AddBefore(tenListNode, 9);
originalLinkedList.AddAfter(tenListNode, fiveHundredListNode);
originalLinkedList.AddLast(last);
originalLinkedList.Remove(10);
originalLinkedList.AddAfter(last, 777);
originalLinkedList.Remove(fiveHundredListNode);
originalLinkedList.RemoveFirst();
originalLinkedList.RemoveLast();
originalLinkedList.Clear();
originalLinkedList.AddLast(5);
originalLinkedList.RemoveFirst();
myLinkedList.AddFirst(myTenListNode);
myLinkedList.AddBefore(myTenListNode, 9);
myLinkedList.AddAfter(myTenListNode, myFiveHundredListNode);
myLinkedList.AddLast(myLast);
myLinkedList.Remove(10);
myLinkedList.AddAfter(myLast, 777);
myLinkedList.Remove(myFiveHundredListNode);
myLinkedList.RemoveFirst();
myLinkedList.RemoveLast();
myLinkedList.Clear();
myLinkedList.AddLast(5);
myLinkedList.RemoveFirst();
}
public void Push(T e)
{
data.AddFirst(e);
}
private static MyLinkedList <MovementTile> FindPath(MovementTile start, MovementTile finish,
bool ignoreOtherCrew, MovementTile blockedException, bool startCanBeBlocked, out bool couldFindPath)
{
if (start.crewMem && !startCanBeBlocked && start != blockedException)
{
couldFindPath = false;
return(new MyLinkedList <MovementTile> ());
}
couldFindPath = true;
if (start == finish)
{
MyLinkedList <MovementTile> path = new MyLinkedList <MovementTile> ();
path.AddFirst(finish);
return(path);
}
if (start.layer != finish.layer)
{
List <LevelLayout.Portal> portalsForPath = layout.GetPortalsToLayerFromLayer(start.layer, finish.layer);
int currentLayer = start.layer;
MovementTile currentTile = start;
MyLinkedList <MovementTile> totalPath = new MyLinkedList <MovementTile> ();
for (int i = 0; i < portalsForPath.Count; i++)
{
MovementTile currentPortalTile = portalsForPath [i].GetHoleForLayer(currentLayer);
MyLinkedList <MovementTile> pathPart = FindPath(currentTile, currentPortalTile, ignoreOtherCrew,
blockedException, i == 0, out couldFindPath); //very gross change to something better
totalPath = MyLinkedList <MovementTile> .CombineLinkedLists(totalPath, pathPart);
if (pathPart.Count > 0 && pathPart.last.data != currentPortalTile)
{
return(totalPath);
}
else if (pathPart.Count == 0)
{
return(totalPath);
}
currentLayer = portalsForPath [i].GetOtherLayer(currentLayer);
currentTile = portalsForPath [i].GetHoleForLayer(currentLayer);
}
MyLinkedList <MovementTile> finalPathPart = FindPath(currentTile, finish, ignoreOtherCrew,
blockedException, false, out couldFindPath);
totalPath = MyLinkedList <MovementTile> .CombineLinkedLists(totalPath, finalPathPart);
return(totalPath);
}
open.Add(start);
start.goal = 0;
start.fitness = DistBetween(start, finish);
MovementTile closestAvailable = start;
while (open.Count != 0)
{
MovementTile current = open.RemoveFirst();
current.closed = true;
if (current == finish)
{
break;
}
MovementTile[] neighbors = GetTileNeighbors(current);
for (int i = 0; i < neighbors.Length; i++)
{
if (neighbors [i] == null || !neighbors [i].walkable || neighbors [i].closed ||
((neighbors[i].shipPos || (!ignoreOtherCrew && neighbors[i].crewMem)) &&
neighbors[i] != blockedException))
{
continue;
}
float tempGoal = current.goal + (DistBetween(current, neighbors [i]) * neighbors [i].weight);
if (!open.Contains(neighbors [i]))
{
neighbors [i].prev = current;
neighbors [i].goal = tempGoal;
neighbors [i].fitness = neighbors [i].goal + DistBetween(neighbors [i], finish);
open.Add(neighbors [i]);
if (neighbors [i].fitness < closestAvailable.fitness)
{
closestAvailable = neighbors [i];
}
}
else if (tempGoal >= neighbors [i].goal)
{
continue;
}
}
}
// PrintPathRetrace (finish);
if (finish.prev == null)
{
couldFindPath = false;
// Debug.LogWarning ("could not path to finish");
CleanMap(start.layer);
return(CreatePath(closestAvailable));
}
MyLinkedList <MovementTile> p = CreatePath(finish);
CleanMap(start.layer);
return(p);
}
static void TestSinglyLinkedList()
{
Console.WriteLine(" ***** Singly Linked List Implementation ***** ");
MyLinkedList <int> testList = new MyLinkedList <int>();
//testing AddFirst
for (int i = 0; i < 6; i++)
{
testList.AddFirst(i);
}
CollectionToString CtoS = new CollectionToString();
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test reverse
testList.Reverse();
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test AddLast
testList.AddLast(7);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test AddAfter
//after head
testList.AddAfter(5, 6);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//in middle
testList.AddAfter(4, 5);
//after end
testList.AddAfter(7, 8);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//handle miss
testList.AddAfter(9, 3);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test AddBefore
//before head
testList.AddBefore(5, 4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//in middle
testList.AddBefore(3, 4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//before last
testList.AddBefore(8, 7);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//handle miss
testList.AddBefore(9, 3);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//test DeleteAt
//first
testList.DeleteAt(4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//middle
testList.DeleteAt(4);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//end
testList.DeleteAt(8);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
//handle miss
testList.DeleteAt(9);
Console.WriteLine(CtoS.MyLinkedListReporter(testList));
}
public static List <Node> PossibleNode = new List <Node>(); // Les noeuds possibles (cases adjacentes de tout le chemin)
public static MyLinkedList <Tile> CalculatePathWithAStar(Map map, Tile startTile, Tile endTile)
{
PossibleNode.Clear();
NodeList <Node> openList = new NodeList <Node>(); // Contiens tout les noeuds candidat (qui vont être examinés)
NodeList <Node> closedList = new NodeList <Node>(); // Contiens la liste des meilleurs noeuds (le resultat du plus cours chemin)
List <Node> possibleNodes; // cases adjacentes du noeud courant
// Le noeud de départ
Node startNode = new Node(startTile, null, endTile); // FIXME : on recupère le noeud de départ
/**********************************/
/* Traitement des noeuds candidat */
/**********************************/
openList.Add(startNode);
while (openList.Count > 0) // Tant que la liste ouverte contient des éléments
{
Node current = openList[0];
openList.RemoveAt(0);
closedList.Add(current);
if (current.Tile == endTile) // si l'élément courant est la case destination
{
MyLinkedList <Tile> solution = new MyLinkedList <Tile>();
// on reverse la liste fermée et on la retourne pour l'avoir dans le bonne ordre
while (current.Parent != null)
{
solution.AddFirst(current.Tile);
current = current.Parent;
}
return(solution);
}
possibleNodes = current.GetPossibleNode(map, endTile); // FIXME : recupère la listes des cases adjacentes
// on ajoute cette liste a notre variable static qui contient l'ensemble des listes adjacentes (gestion de l'affichage)
PossibleNode.AddRange(possibleNodes);
/***************************************/
/* Ajout des noeuds adjacents candidat */
/***************************************/
for (int i = 0; i < possibleNodes.Count; i++) // on vérifie que chaque noeuds adjacent (possibleNodes)
{
if (!closedList.Contains(possibleNodes[i])) // n'existe pas dans la liste fermée (eviter la redondance)
{
if (openList.Contains(possibleNodes[i])) // FIXME : Si il existe dans la liste ouverte on vérifie
{
if (possibleNodes[i].EstimatedMovement < openList[possibleNodes[i]].EstimatedMovement) // si le cout de deplacement du
// noeud est inferieur a un coût calculer précedement, dance cas la on remonte le chemin dans la liste ouverte
{
openList[possibleNodes[i]].Parent = current;
}
}
else
{
openList.DichotomicInsertion(possibleNodes[i]);
}
}
}
}
return(null);
}
public void Push(T data)
{
_myLinkedList.AddFirst(data);
}
public void Push(T data)
{
stack.AddFirst(data);
}
