comments cleanup

Author: justcoding121

Advanced.Algorithms/DataStructures/Heap/Max/BinomialMaxHeap.cs

@@ -135,7 +135,6 @@ public void Merge(BinomialMaxHeap<T> binomialHeap)
         /// <summary>
         /// Time complexity: O(log(n)).
         /// </summary>
-        /// <returns></returns>
         public T PeekMax()
         {
             if (heapForest.Head == null)

Advanced.Algorithms/DataStructures/Heap/Min/BinomialMinHeap.cs

@@ -135,7 +135,6 @@ public void Merge(BinomialMinHeap<T> binomialHeap)
         /// <summary>
         /// Time complexity: O(log(n)).
         /// </summary>
-        /// <returns></returns>
         public T PeekMin()
         {
             if (heapForest.Head == null)

Advanced.Algorithms/DataStructures/LinkedList/DoublyLinkedList.cs

@@ -198,7 +198,7 @@ public T DeleteFirst()
         /// Delete tail node.
         /// Time complexity: O(1)
         /// </summary>
-        /// <returns></returns>
+        /// 
         public T DeleteLast()
         {
             if (Tail == null)
@@ -344,7 +344,7 @@ internal void Union(DoublyLinkedList<T> newList)
         /// <summary>
         /// Time complexity: O(1).
         /// </summary>
-        /// <returns></returns>
+        /// 
         public bool IsEmpty() => Head == null;
 
         /// <summary>

Advanced.Algorithms/DataStructures/LinkedList/SinglyLinkedList.cs

@@ -51,7 +51,6 @@ public void InsertLast(T data)
         /// <summary>
         /// Time complexity: O(1).
         /// </summary>
-        /// <returns></returns>
         public T DeleteFirst()
         {
             if (Head == null)
@@ -69,7 +68,6 @@ public T DeleteFirst()
         /// <summary>
         /// Time complexity: O(n).
         /// </summary>
-        /// <returns></returns>
         public T DeleteLast()
         {
             if (Head == null)

Advanced.Algorithms/DataStructures/List/ArrayList.cs

@@ -56,7 +56,6 @@ public ArrayList(IEnumerable<T> initial)
         /// Time complexity: O(1).
         /// </summary>
         /// <param name="index">The index to write or read.</param>
-        /// <returns></returns>
         public T this[int index]
         {
             get => itemAt(index);
@@ -75,7 +74,6 @@ private T itemAt(int i)
         /// Add a new item to this array list.
         /// Time complexity: O(1) amortized.
         /// </summary>
-        /// <param name="item"></param>
         public void Add(T item)
         {
             grow();

Advanced.Algorithms/DataStructures/List/SkipList.cs

@@ -41,8 +41,6 @@ public SkipList(int maxHeight = 32)
         /// If item is not found default value of T will be returned.
         /// Time complexity: O(log(n)).
         /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
         public T Find(T value)
         {
             var current = Head;

Advanced.Algorithms/DataStructures/Queues/PriorityQueue/MaxPriorityQueue.cs

@@ -23,7 +23,6 @@ public void Enqueue(T item)
         /// <summary>
         /// Time complexity:O(log(n)).
         /// </summary>
-        /// <returns></returns>
         public T Dequeue()
         {
             return maxHeap.ExtractMax();
@@ -32,7 +31,6 @@ public T Dequeue()
         /// <summary>
         /// Time complexity:O(1).
         /// </summary>
-        /// <returns></returns>
         public T Peek()
         {
             return maxHeap.PeekMax();

Advanced.Algorithms/DataStructures/Queues/PriorityQueue/MinPriorityQueue.cs

@@ -31,7 +31,6 @@ public T Dequeue()
         /// <summary>
         /// Time complexity:O(1).
         /// </summary>
-        /// <returns></returns>
         public T Peek()
         {
             return minHeap.PeekMin();

Advanced.Algorithms/DataStructures/Queues/Queue.cs

@@ -31,7 +31,6 @@ public Queue(QueueType type = QueueType.Array)
         /// <summary>
         /// Time complexity:O(1).
         /// </summary>
-        /// <param name="item"></param>
         public void Enqueue(T item)
         {
             queue.Enqueue(item);
@@ -40,7 +39,6 @@ public void Enqueue(T item)
         /// <summary>
         /// Time complexity:O(1).
         /// </summary>
-        /// <returns></returns>
         public T Dequeue()
         {
             return queue.Dequeue();

Advanced.Algorithms/DataStructures/Tree/B+Tree.cs

@@ -945,7 +945,6 @@ internal BpTreeNode(int maxKeysPerNode, BpTreeNode<T> parent)
         /// <summary>
         /// For shared test method accross B and B+ tree
         /// </summary>
-        /// <returns></returns>
         internal override BNode<T> GetParent()
         {
             return Parent;
@@ -954,7 +953,6 @@ internal override BNode<T> GetParent()
         /// <summary>
         /// For shared test method accross B and B+ tree
         /// </summary>
-        /// <returns></returns>
         internal override BNode<T>[] GetChildren()
         {
             return Children;

Advanced.Algorithms/DataStructures/Tree/BST.cs

@@ -8,7 +8,6 @@ namespace Advanced.Algorithms.DataStructures
     /// <summary>
     /// A binary search tree implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class BST<T> : IEnumerable<T> where T : IComparable
     {
         internal BSTNode<T> Root { get; set; }
@@ -380,8 +379,6 @@ public T NextLower(T value)
         ///     Get the value next to given value in this BST.
         ///     Time complexity: O(n)
         /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
         public T NextHigher(T value)
         {
             var node = find(value);

Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs

@@ -7,7 +7,6 @@ namespace Advanced.Algorithms.DataStructures
     /// <summary>
     /// A red black tree implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class RedBlackTree<T> : IEnumerable<T> where T : IComparable
     {     
         private readonly Dictionary<T, BSTNodeBase<T>> nodeLookUp;
@@ -779,7 +778,6 @@ internal enum RedBlackTreeNodeColor
     /// <summary>
     /// Red black tree node
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     internal class RedBlackTreeNode<T> : BSTNodeBase<T> where T : IComparable
     {
         internal new RedBlackTreeNode<T> Parent

Advanced.Algorithms/DataStructures/Tree/SplayTree.cs

@@ -7,7 +7,6 @@ namespace Advanced.Algorithms.DataStructures
     /// <summary>
     /// A splay tree implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class SplayTree<T> : IEnumerable<T> where T : IComparable
     {
         private SplayTreeNode<T> root { get; set; }

Advanced.Algorithms/DataStructures/Tree/TreapTree.cs

@@ -334,8 +334,6 @@ private void heapify(TreapTreeNode<T> node)
         /// <summary>
         /// Rotates current root right and returns the new root node
         /// </summary>
-        /// <param name="currentRoot"></param>
-        /// <returns></returns>
         private TreapTreeNode<T> rightRotate(TreapTreeNode<T> currentRoot)
         {
             var prevRoot = currentRoot;

Advanced.Algorithms/Distributed/CircularQueue.cs

@@ -7,7 +7,6 @@ namespace Advanced.Algorithms.Distributed
     /// <summary>
     /// Cicular queue aka Ring Buffer using fixed size array.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class CircularQueue<T>
     {
         private T[] queue;

Advanced.Algorithms/Graph/Cycle/CycleDetection.cs

@@ -6,7 +6,6 @@ namespace Advanced.Algorithms.Graph
     /// <summary>
     /// Cycle detection using Depth First Search.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class CycleDetector<T>
     {
         /// <summary>

Advanced.Algorithms/Search/BoyerMoore.cs

@@ -7,7 +7,6 @@ namespace Advanced.Algorithms.Search
     /// <summary>
     /// A boyer-moore majority finder algorithm implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class BoyerMoore<T> where T : IComparable
     {
         public static T FindMajority(IEnumerable<T> input)

Advanced.Algorithms/Search/QuickSelect.cs

@@ -8,7 +8,6 @@ namespace Advanced.Algorithms.Search
     /// <summary>
     /// A quick select for Kth smallest algorithm implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class QuickSelect<T> where T : IComparable
     {
         public static T FindSmallest(IEnumerable<T> input, int k)

Advanced.Algorithms/Sorting/InsertionSort.cs

@@ -5,7 +5,6 @@ namespace Advanced.Algorithms.Sorting
     /// <summary>
     /// An insertion sort implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class InsertionSort<T> where T : IComparable
     {
         /// <summary>