public void ConstructListSucceeds() { IList <int> list = new SortedLinkedList <int>(); Assert.IsNotNull(list); Assert.IsTrue(list.Length() == 0); }
public SortedLinkedList <T> SymmetricDifferenceList(TwoThreeTree <T> B) { SortedLinkedList <T> ANB = UnionList(B); //A OR B SortedLinkedList <T> BNA = IntersectionList(B); //A AND B. return(ANB.Difference(BNA)); //A OR B - (A AND B) }
public static void Main(string[] args) { LinkedList <int> theList = new SortedLinkedList <int>( ); LinkedListIterator <int> theItr; int i; theItr = theList.Zeroth( ); PrintList(theList); for (i = 0; i < 10; i++) { theList.Insert(i * 7 % 10, theItr); PrintList(theList); theItr.Advance( ); } for (i = 0; i < 10; i += 2) { theList.Remove(i); } for (i = 0; i < 10; i++) { if ((i % 2 == 0) == (theList.Find(i).IsValid( ))) { Console.WriteLine("Find fails!"); } } Console.WriteLine("Finished deletions"); PrintList(theList); }
public void EmptyFlagFalseInNonEmptyLinkedList() { var list = new SortedLinkedList <int>(); list.Insert(4); Assert.IsFalse(list.IsEmpty()); }
public void RemoveItemSucceeds() { IList <int> list = new SortedLinkedList <int>(); list.AddItem(16); list.AddItem(3); list.AddItem(11); list.AddItem(4); list.AddItem(25); Assert.IsTrue(list.Length() == 5); Assert.IsTrue(list.GetNextItem() == 3); Assert.IsTrue(list.GetNextItem() == 4); Assert.IsTrue(list.GetNextItem() == 11); Assert.IsTrue(list.GetNextItem() == 16); Assert.IsTrue(list.GetNextItem() == 25); list.RemoveItem(11); list.ResetList(); Assert.IsTrue(list.GetNextItem() == 3); Assert.IsTrue(list.GetNextItem() == 4); Assert.IsTrue(list.GetNextItem() == 16); Assert.IsTrue(list.GetNextItem() == 25); }
public static SortedLinkedList<VocabularyItem> Collect(TrieNode root) { _itemsCollectedInCurThread = new SortedLinkedList<VocabularyItem> (Configuration.Default.MaxWordsNumberToReturn); CollectFromNode(root); return _itemsCollectedInCurThread; }
public void InsertInSortedListTest1() { SortedLinkedList <int> sortedLinkedList = new SortedLinkedList <int>(); sortedLinkedList.Insert(27); Assert.Equal(expected: "27,", actual: sortedLinkedList.ToString()); }
public void RemoveElementFromEmptyList_DoesNotThrow() { var list = new SortedLinkedList <string>((a, b) => a.CompareTo(b)); Assert.Empty(list); list.Remove("Not Present"); Assert.Empty(list); }
public void ClearElementsFromEmptyList() { var list = new SortedLinkedList <string>((a, b) => a.CompareTo(b)); Assert.Empty(list); list.Clear(); Assert.Empty(list); }
public void AddItemFailsWithDuplicateItem() { IList <int> list = new SortedLinkedList <int>(); list.AddItem(16); Assert.ThrowsException <InvalidOperationException>(() => list.AddItem(16)); }
public void AddItemSucceeds() { IList <int> list = new SortedLinkedList <int>(); list.AddItem(16); Assert.IsTrue(list.Contains(16)); }
public void ctorTest() { //Act var list = new SortedLinkedList(); //Assert Assert.Null(list.Head); }
public void RemoveShouldNotUpdateCountWhenNotFound() { SortedLinkedList <int> list = new SortedLinkedList <int>(); list.Add(1); Assert.IsFalse(list.Remove(2), "Remove should return false on failure"); Assert.AreEqual(1, list.Count, "Remove shoud not decrement count on failure"); }
public void AddToEmptyListShouldNoLongerBeEmpty() { SortedLinkedList <int> list = new SortedLinkedList <int>(); Assert.IsTrue(list.IsEmpty, "New list should be empty"); list.Add(1); Assert.IsFalse(list.IsEmpty, "Added item should no longer be empty list"); }
public void EmptyList() { var list = new SortedLinkedList <Int32>(compareLogic_Ascending); Assert.NotNull(list); Assert.Empty(list); Assert.Equal(0, list.Count); Assert.Equal(null, list.First?.Value); }
public void RemoveShouldDecrementCountWhenFound() { SortedLinkedList <int> list = new SortedLinkedList <int>(); list.Add(1); Assert.IsTrue(list.Remove(1), "Remove should return true on success"); Assert.AreEqual(0, list.Count, "Remove should decrement count on success"); }
public void RemoveOfSingleItemInListShouldNowBeEmpty() { SortedLinkedList <int> list = new SortedLinkedList <int>(); list.Add(1); _ = list.Remove(1); Assert.IsTrue(list.IsEmpty, "Remove should update IsEmpty on success"); }
public void AddShouldIncrementCount() { SortedLinkedList <int> list = new SortedLinkedList <int>(); Assert.AreEqual(0, list.Count, "New list should have count of 0"); list.Add(1); Assert.AreEqual(1, list.Count, "Add should increment count"); }
public void AddSingleElementToEmptyList() { int element = 34; var list = new SortedLinkedList <int>(compareLogic_Ascending); list.Add(element); Assert.Equal(list.Count, 1); Assert.Equal(list.First.Value, element); }
public void TestClear() { var list = new SortedLinkedList <int>(); list.Insert(5); list.Insert(-4); list.Clear(); Assert.AreEqual(0, list.Size); Assert.True(list.IsEmpty()); }
public void SearchShouldReturnNullWhenNotFound() { SortedLinkedList <int> list = new SortedLinkedList <int>(); list.Add(1); DoubleLinkedNode <int> actual = list.Search(2); Assert.IsNull(actual, "Search should return null result when value does not exist in the list"); }
public void ListIsFullFails() { IList <int> list = new SortedLinkedList <int>(); list.AddItem(16); list.AddItem(3); list.AddItem(11); Assert.IsFalse(list.IsFull()); }
public void SearchShouldReturnNonNullWhenFound() { SortedLinkedList <int> list = new SortedLinkedList <int>(); list.Add(1); DoubleLinkedNode <int> actual = list.Search(1); Assert.IsNotNull(actual, "Search should return non-null result when value exists in the list"); Assert.AreEqual(1, actual.Value, "Search should return the correct value when it exists in the list"); }
public void GivenNumbers_WhenAdded_ShouldBeInAscendingOrder() { SortedLinkedList list = new SortedLinkedList(); list.AddElement(56); list.AddElement(30); list.AddElement(40); list.AddElement(70); Assert.AreEqual(30, list.head.data); }
public void TestSimpleLinkedListAddition() { var list = new SortedLinkedList <int>(); list.Add(0); list.Add(1); list.Add(3); list.Add(2); Assert.AreEqual(2, list.ElementAt(2)); }
private void Init() { this.solutionPathList = new ArrayList(); this.ignoredPathList = new ArrayList(); this.startNode = new Node(null, this.goalNode, G_COST, this.formula, START_POINT, START_POINT); this.goalNode = new Node(null, null, G_COST, this.formula, MAP_SIZE, MAP_SIZE); this.openList = new SortedLinkedList(); this.closedList = new SortedLinkedList(); }
/// <summary> /// Tests the <see cref="SortedLinkedList{T}.Add(T)"/> method to ensure /// that sort order is maintained. /// </summary> public void AddShouldMaintainSortOrder() { SortedLinkedList <int> list = new SortedLinkedList <int>(); list.Add(1); list.Add(7); list.Add(34); list.Add(-1); list.Add(9); Assert.AreEqual("34, 9, 7, 1, -1", list.ToString(), "Sort order should be maintained by adding values"); }
public void RemoveItemFailsWithMissingItem() { IList <int> list = new SortedLinkedList <int>(); list.AddItem(16); list.AddItem(3); list.AddItem(11); list.AddItem(4); list.AddItem(25); Assert.ThrowsException <InvalidOperationException>(() => list.RemoveItem(32)); }
public void TestMethod1() { var list = new SortedLinkedList <int>(); list.Add(5); list.Add(1); list.Add(3); list.Add(6); list.Add(10); list.Add(3); list.Add(5); }
public void AddMultipleElementsToList_OrderedAscending_SortedAscending() { int[] ordered = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var list = new SortedLinkedList <int>(compareLogic_Ascending); foreach (int i in ordered) { list.Add(i); } Assert.Equal(list.Count, ordered.Length); Assert.Equal(list.ToArray(), ordered); }
public void ClearElementsFromList() { var list = new SortedLinkedList <string>((a, b) => a.CompareTo(b)); list.Add("A"); list.Add("B"); list.Add("C"); Assert.Equal(list.Count, 3); list.Clear(); Assert.Empty(list); }
/// <summary> /// erstellt eine neue NodeConnection /// </summary> /// <param name="startNode">Anfangsknoten</param> /// <param name="endNode">Endknoten</param> /// <param name="ls">LineSegment</param> /// <param name="priority">Priorität</param> /// <param name="targetVelocity">target velocity</param> /// <param name="carsAllowed">Flag, ob Autos auf dieser NodeConnection erlaubt sind</param> /// <param name="busAllowed">Flag, ob Busse auf dieser NodeConnection erlaubt sind</param> /// <param name="tramAllowed">Flag, ob Straßenbahnen auf dieser NodeConnection erlaubt sind</param> /// <param name="enableIncomingLineChange">Flag, ob Spurwechsel auf diese NodeConnection erlaubt sind</param> /// <param name="enableOutgoingLineChange">Flag, ob Spurwechsel von dieser NodeConnection erlaubt sind</param> public NodeConnection( LineNode startNode, LineNode endNode, LineSegment ls, int priority, double targetVelocity, bool carsAllowed, bool busAllowed, bool tramAllowed, bool enableIncomingLineChange, bool enableOutgoingLineChange) { // TODO: NodeConnections werden stets mit lineSegment = null initialisiert? Warum? this.startNode = startNode; this.endNode = endNode; lineSegment = ls; this._priority = priority; this._targetVelocity = targetVelocity; this._carsAllowed = carsAllowed; this._busAllowed = busAllowed; this._tramAllowed = tramAllowed; this._enableIncomingLineChange = enableIncomingLineChange; this._enableOutgoingLineChange = enableOutgoingLineChange; UpdatePen(); intersectionComparer = delegate(Intersection a, Intersection b) { bool aA = (this == a._aConnection); bool bA = (this == b._aConnection); if (aA && bA) return a._aTime.CompareTo(b._aTime); else if (!aA && bA) return a._bTime.CompareTo(b._aTime); else if (aA && !bA) return a._aTime.CompareTo(b._bTime); else return a._bTime.CompareTo(b._bTime); }; _intersections = new SortedLinkedList<Intersection>(intersectionComparer); statistics = new Statistics[1]; }
/// <summary> /// Standardconstruktor (!!! NICHT VERVENDEN !!!) [wird nur für XML Serialisierung gebraucht] /// </summary> public NodeConnection() { //** Hier passiert gar nix - die NodeConnection ist nicht funktionsfähig ***\\ // den intersectionComparer müssen wir trotzdem erstellen... intersectionComparer = delegate(Intersection a, Intersection b) { bool aA = (this == a._aConnection); bool bA = (this == b._aConnection); if (aA && bA) return a._aTime.CompareTo(b._aTime); else if (!aA && bA) return a._bTime.CompareTo(b._aTime); else if (aA && !bA) return a._aTime.CompareTo(b._bTime); else return a._bTime.CompareTo(b._bTime); }; _intersections = new SortedLinkedList<Intersection>(intersectionComparer); statistics = new Statistics[1]; }
static void Main(string[] args) { int choice, data; SortedLinkedList List = new SortedLinkedList(); List.Create(); while (true) { Console.WriteLine(" 1.Display the List."); Console.WriteLine(" 2.Insert a new Node."); Console.WriteLine(" 3.Search."); Console.WriteLine(" 4.Exit."); Console.WriteLine("Please enter your Choice: "); choice = Convert.ToInt32(Console.ReadLine()); if (choice == 4) { break; } switch (choice) { case 1: List.DisplayList(); break; case 2: try { Console.WriteLine("Please write the Node to be inserted:"); data = Convert.ToInt32(Console.ReadLine()); List.InsertInOrder(data); } catch (Exception anExpected) { Console.WriteLine(anExpected.Message); } break; case 3: try { Console.WriteLine("Please write which Node to be Search? "); data = Convert.ToInt32(Console.ReadLine()); List.Search(data); } catch (Exception anExpected) { Console.WriteLine(anExpected.Message); } break; case 4: Console.WriteLine("The program is terminated: "); break; default: Console.WriteLine("Incorrect"); break; } } }
/// <summary> /// Złącza pliki wynikowe obiektów tworzących w plik odwróconego indeksu /// /// Złącza wszystkie pliki tymczasowe posortowane wszystkich obiektów celu zapisu indeksu IxStdDiskRIIndex.Writer w jeden plik /// posortowany wg ID tokenów rosnąco, wag wystąpień w dokumentach malejąco. Tworzy indeks na plik danych. /// </summary> private void mergeAll() { /* Posortowana lista czytaczy plików tymczasowych */ SortedLinkedList<TmpPostingsFileReader> sordedReaders = new SortedLinkedList<TmpPostingsFileReader>(); /* Dodaj do listy czytacze plików ze wszystkich obiektów celu zapisu indeksu */ for (int i = 0; i < writers.Count; i++) { TmpPostingsFileReader[] readers = writers[i].getTmpPostingsFileReaders(); foreach (TmpPostingsFileReader reader in readers) sordedReaders.add(reader); } /* Utwórz strumienie binarne do zapisu danych indeksu i indeksu indeksu i używając ich */ using (BinaryWriter postingsFileWriter = new BinaryWriter(File.Create(indexDirPath + "postings.dat")), postingsIndexFileWriter = new BinaryWriter(File.Create(indexDirPath + "postings.idx"))) { /* Wybierz czytacz pliku tymczasowego o najniższym ID tokenu, najwyższej wadze (tak są posortowane) */ TmpPostingsFileReader first = sordedReaders.getFirst(); /* Na potrzeby tworzenia indeksu */ uint lastTokenId = first.current().tokenId; uint count = 0; long offset = 0, startOffset = 0; /* Nie istnieje token o ID 0, dlatego musimy mu sztucznie wstawić wpis indeksu (zerowy) * aby mechanizmy działały poprawnie */ if (lastTokenId == 1) writeIndex(postingsIndexFileWriter, 0, 0); do { /* Usuń z listy pierwszy czytacz */ sordedReaders.remove(first); /* Jeśli zmienił się ID tokenu, zapisz wpis w indeksie */ if (first.current().tokenId != lastTokenId) { writeIndex(postingsIndexFileWriter, startOffset, count); lastTokenId = first.current().tokenId; count = 0; startOffset = offset; } /* Zapisz wystąpienie, już bez ID tokenu, do pliku danych indeksu */ writePosting(postingsFileWriter, first.current().posting); offset += Posting.size; count++; /* Spróbuj odczytać następne wystąpienie przez czytacz, jeśli to nie koniec jego pliku, * dodaj go do listy (sortowanie zostanie zachowane) */ first.moveNext(); if (!first.end()) sordedReaders.add(first); } while ((first = sordedReaders.getFirst()) != null); // Póki jest jeszcze jakiś czytacz /* Zapisz ostatni wpis indeksu */ writeIndex(postingsIndexFileWriter, startOffset, count); } }