public StackGeneric(int initialCapacity) { if (initialCapacity < 0) { throw new ArgumentOutOfRangeException(); } // The internal collection is implemented as an array-based list. // See the ArrayList.cs for the list implementation. _collection = new ArrayListGeneric <T>(initialCapacity); }
/// <summary> /// Heapifies the specified newCollection. Overrides the current heap. /// </summary> public void Initialize(IList <T> newCollection) { if (newCollection.Count > 0) { // Reset and reserve the size of the newCollection _collection = new ArrayListGeneric <T>(newCollection.Count); // Copy the elements from the newCollection to the inner collection for (int i = 0; i < newCollection.Count; ++i) { _collection.InsertAt(newCollection[i], i); } // Build the heap _buildMaxHeap(); } }
/// <summary> /// A breadth first search traversal of the graph, starting from a specified vertex. /// Returns the visited vertices of the graph. /// </summary> public virtual IEnumerable <T> BreadthFirstWalk(T source) { if (VerticesCount == 0) { return(new ArrayListGeneric <T>()); } else if (!HasVertex(source)) { throw new Exception("The specified starting vertex doesn't exist."); } var visited = new HashSet <T>(); var queue = new QueueGeneric <T>(VerticesCount); var listOfNodes = new ArrayListGeneric <T>(VerticesCount); listOfNodes.Add(source); visited.Add(source); queue.Enqueue(source); while (!queue.IsEmpty) { var current = queue.Dequeue(); var neighbors = Neighbours(current); foreach (var adjacent in neighbors) { if (!visited.Contains(adjacent)) { listOfNodes.Add(adjacent); visited.Add(adjacent); queue.Enqueue(adjacent); } } } return(listOfNodes); }
/// <summary> /// Finds all the elements that match the typed Search Predicate. /// </summary> /// <returns>ArrayList<T> of matched elements. Empty list is returned if not element was found.</returns> /// <param name="searchMatch">Match predicate.</param> public ArrayListGeneric <T> FindAll(Predicate <T> searchMatch) { // Null Predicate functions are not allowed. if (searchMatch == null) { throw new ArgumentNullException(); } ArrayListGeneric <T> matchedElements = new ArrayListGeneric <T>(); // Begin searching, and add the matched elements to the new list. for (int i = 0; i < _size; ++i) { if (searchMatch(_collection[i])) { matchedElements.Add(_collection[i]); } } // Return the new list of elements. return(matchedElements); }
/// <summary> /// A depth first search traversal of the graph, starting from a specified vertex. /// Returns the visited vertices of the graph. /// </summary> public virtual IEnumerable <T> DepthFirstWalk(T source) { // Check for existence of source if (VerticesCount == 0) { return(new ArrayListGeneric <T>(0)); } else if (!HasVertex(source)) { throw new KeyNotFoundException("The source vertex doesn't exist."); } var visited = new HashSet <T>(); var stack = new StackGeneric <T>(); var listOfNodes = new ArrayListGeneric <T>(VerticesCount); stack.Push(source); while (!stack.IsEmpty) { var current = stack.Pop(); if (!visited.Contains(current)) { listOfNodes.Add(current); visited.Add(current); foreach (var adjacent in Neighbours(current)) { if (!visited.Contains(adjacent)) { stack.Push(adjacent); } } } } return(listOfNodes); }
/// <summary> /// Get a range of elements, starting from an index.. /// </summary> /// <returns>The range as ArrayList<T>.</returns> /// <param name="startIndex">Start index to get range from.</param> /// <param name="count">Count of elements.</param> public ArrayListGeneric <T> GetRange(int startIndex, int count) { // Handle the bound errors of startIndex if (startIndex < 0 || (uint)startIndex > (uint)_size) { throw new IndexOutOfRangeException("Please provide a valid starting index."); } // Handle the bound errors of count and startIndex with respect to _size if (count < 0 || startIndex > (_size - count)) { throw new ArgumentOutOfRangeException(); } var newArrayList = new ArrayListGeneric <T>(count); // Use Array.Copy to quickly copy the contents from this array to the new list's inner array. System.Array.Copy(_collection, startIndex, newArrayList._collection, 0, count); // Assign count to the new list's inner _size counter. newArrayList._size = count; return(newArrayList); }
public BinaryMaxHeap(int capacity, Comparer <T> comparer) { _collection = new ArrayListGeneric <T>(capacity); _heapComparer = comparer ?? Comparer <T> .Default; }
/// <summary> /// CONSTRUCTORS /// </summary> public StackGeneric() { // The internal collection is implemented as an array-based list. // See the ArrayList.cs for the list implementation. _collection = new ArrayListGeneric <T>(); }