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