Added short documentations at the header of classes.

Author: aalhour

Algorithms/Graphs/BreadthFirstSearcher.cs

@@ -1,4 +1,15 @@
-using System;
+/***
+ * Implements the the Breadth-First Search algorithm. 
+ * 
+ * Provides multiple functions for traversing graphs: 
+ *  1. PrintAll(), 
+ *  2. VisitAll(Action<T> forEachFunc), 
+ *  3. FindFirstMatch(Predicate<T> match). 
+ *  
+ * The VisitAll() applies a function to every graph node. The FindFirstMatch() function searches the graph for a predicate match.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Graphs;

Algorithms/Graphs/BreadthFirstShortestPaths.cs

@@ -1,4 +1,9 @@
-using System;
+/***
+ * Computes Shortest-Paths for Unweighted Graphs using the Breadth-First Search algorithm.
+ * It provides the capability to find shortest-paths from a single-source and multiple-sources, in addition to looking up reachable and unreachable nodes.
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 

Algorithms/Graphs/CyclesDetector.cs

@@ -1,4 +1,8 @@
-using System;
+/***
+ * Detects if a given graph is cyclic. Supports directed and undirected graphs.
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 

Algorithms/Graphs/DepthFirstSearcher.cs

@@ -1,4 +1,15 @@
-using System;
+/***
+ * Implements the Depth-First Search algorithm in two ways: Iterative and Recursive. 
+ * 
+ * Provides multiple functions for traversing graphs: 
+ *  1. PrintAll(), 
+ *  2. VisitAll(Action<T> forEachFunc), 
+ *  3. FindFirstMatch(Predicate<T> match). 
+ * 
+ * The VisitAll() applies a function to every graph node. The FindFirstMatch() function searches the graph for a predicate match.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Graphs;

Algorithms/Graphs/DijkstraAllPairsShortestPaths.cs

@@ -1,4 +1,10 @@
-using System;
+/***
+ * Computes Dijktra's shortest paths for all pairs of vertices in a graph. 
+ * This is a wrapper class that applies single-source dijkstra shortest paths (DijkstraShortestPaths<TG, TV>) 
+ * to all vertices of a graph and saves the results in a dictionary index by the vertices.
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 

Algorithms/Graphs/DijkstraShortestPaths.cs

@@ -1,4 +1,9 @@
-using System;
+/***
+ * Computes Dijkstra's Shortest-Paths for Directed Weighted Graphs from a single-source to all destinations. 
+ * This class provides the same API as the BreadthFirstShortestPaths<T>.
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 

Algorithms/Graphs/TopologicalSorter.cs

@@ -1,4 +1,9 @@
-using System;
+/***
+ * Computes one topological sorting of a DAG (Directed Acyclic Graph). 
+ * This class depends on the CyclesDetector static class.
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 

Algorithms/Numeric/CatalanNumbers.cs

@@ -1,4 +1,10 @@
-using System;
+/***
+ * Computes the Catalan Numbers. A dynamic-programming solution.
+ * 
+ * Wikipedia: https://en.wikipedia.org/wiki/Catalan_number
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 

Algorithms/Strings/Permutations.cs

@@ -1,7 +1,11 @@
-using System;
+/***
+ * Algorithms for computing the list of permutations of a string and checking if two strings are anagrams of each other.
+ */
+
+using System;
 using System.Collections.Generic;
 
-namespace Algorithms
+namespace Algorithms.Strings
 {
 	public static class Permutations
 	{

DataStructures/Dictionaries/ChainedHashTable.cs

@@ -1,4 +1,10 @@
-using System;
+/***
+ * Chained Hash Table.
+ * 
+ * A hash table that implements the Separate-Chaining scheme for resolving keys-collisions. It also implements auto-resizing (expansion and contraction).
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Common;

DataStructures/Dictionaries/CuckooHashTable.cs

@@ -1,4 +1,11 @@
-using System;
+/***
+ * Cuckoo Hash Table.
+ * 
+ * A hash table that implements the Cuckoo Hashing algorithm for resolving keys-collisions. 
+ * This is a single-table implementation, the source behind this idea is the work of Mark Allen Weiss, 2014.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Common;

DataStructures/Graphs/DirectedDenseGraph.cs

@@ -1,20 +1,23 @@
-using System;
+/***
+ * The Directed Dense Graph Data Structure.
+ * 
+ * Definition:
+ * A dense graph is a graph G = (V, E) in which |E| = O(|V|^2).
+ * A directed graph is a graph where each edge follow one direction only between any two vertices.
+ * 
+ * An incidence-matrix digraph representation. Follows almost the same implementation 
+ * details of the Undirected version, except for managing the directed edges.
+ * Implements the IGraph<T> interface.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Common;
 using DataStructures.Lists;
 
 namespace DataStructures.Graphs
 {
-    /// <summary>
-    /// The Directed Dense Graph Data Structure.
-    /// 
-    /// Definition:
-    /// A dense graph is a graph G = (V, E) in which |E| = O(|V|^2).
-    /// A directed graph is a graph where each edge follow one direction only between any two vertices.
-    /// 
-    /// This class represents the graph as an incidence-matrix (two dimensional boolean array).
-    /// </summary>
     public class DirectedDenseGraph<T> : IGraph<T> where T : IComparable<T>
     {
         /// <summary>

DataStructures/Graphs/DirectedSparseGraph.cs

@@ -1,19 +1,21 @@
-using System;
+/***
+ * The Directed Sparse Graph Data Structure.
+ * 
+ * Definition:
+ * A sparse graph is a graph G = (V, E) in which |E| = O(|V|).
+ * A directed graph is a graph where each edge follow one direction only between any two vertices.
+ * 
+ * An adjacency-list digraph (directed-graph) representation. 
+ * Implements the IGraph<T> interface.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Lists;
 
 namespace DataStructures.Graphs
 {
-    /// <summary>
-    /// The Directed Sparse Graph Data Structure.
-    /// 
-    /// Definition:
-    /// A sparse graph is a graph G = (V, E) in which |E| = O(|V|).
-    /// A directed graph is a graph where each edge follow one direction only between any two vertices.
-    /// 
-    /// This class represents the digraph as an adjacency list (dictionary).
-    /// </summary>
     public class DirectedSparseGraph<T> : IGraph<T> where T : IComparable<T>
     {
         /// <summary>

DataStructures/Graphs/DirectedWeightedDenseGraph.cs

@@ -1,18 +1,25 @@
-using System;
+/***
+ * The Directed Weighted Dense Graph Data Structure.
+ * 
+ * Definition:
+ * A dense graph is a graph G = (V, E) in which |E| = O(|V|^2).
+ * A directed graph is a graph where each edge follow one direction only between any two vertices.
+ * A weighted graph is a graph where each edge has a weight (zero weights mean there is no edge).
+ * 
+ * An adjacency-matrix (two dimensional array of longs) weighted digraph representation. 
+ * Inherits and extends the Directed Dense verion (DirectedDenseGraph<T> class).
+ * Implements the IWeightedGraph<T> interface.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Common;
 using DataStructures.Lists;
 
 namespace DataStructures.Graphs
 {
-    /// <summary>
-    /// The Directed Weighted Dense Graph Data Structure.
-    /// 
-    /// Definition:
-    /// A dense graph is a graph G = (V, E) in which |E| = O(|V|^2).
-    /// A directed graph is a graph where each edge follow one direction only between any two vertices.
-    /// A weighted graph is a graph where each edge has a weight (zero weights mean there is no edge).
+   
     /// 
     /// This class represents the graph as an adjacency-matrix (two dimensional integer array).
     /// </summary>

DataStructures/Graphs/DirectedWeightedSparseGraph.cs

@@ -1,4 +1,17 @@
-using System;
+/***
+ * The Directed Sparse Graph Data Structure.
+ * 
+ * Definition:
+ * A sparse graph is a graph G = (V, E) in which |E| = O(|V|).
+ * A directed graph is a graph where each edge follow one direction only between any two vertices.
+ * A weighted graph is a graph where each edge has a weight (zero weights mean there is no edge).
+ * 
+ * An adjacency-list weighted digraph representation. Shares a good deal of implemention details 
+ * with the Directed Sparse version (DirectedSparseGraph<T>). Edges are instances of WeightedEdge<T> class. 
+ * Implements both interfaces: IGraph<T> and IWeightedGraph<T>.
+ */
+
+using System;
 using System.Diagnostics;
 using System.Collections.Generic;
 
@@ -7,16 +20,6 @@
 
 namespace DataStructures.Graphs
 {
-    /// <summary>
-    /// The Directed Sparse Graph Data Structure.
-    /// 
-    /// Definition:
-    /// A sparse graph is a graph G = (V, E) in which |E| = O(|V|).
-    /// A directed graph is a graph where each edge follow one direction only between any two vertices.
-    /// A weighted graph is a graph where each edge has a weight (zero weights mean there is no edge).
-    /// 
-    /// This class represents the digraph as an adjacency-list (dictionary).
-    /// </summary>
     public class DirectedWeightedSparseGraph<T> : IGraph<T>, IWeightedGraph<T> where T : IComparable<T>
     {
         /// <summary>

DataStructures/Graphs/UndirectedDenseGraph.cs

@@ -1,19 +1,20 @@
-using System;
+/***
+ * The Dense Graph Data Structure.
+ * 
+ * Definition: A dense graph is a graph G = (V, E) in which |E| = O(|V|^2).
+ * 
+ * An incidence-matrix (two dimensional boolean array) graph representation.
+ * This class implements the IGraph<T> interface.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Common;
 using DataStructures.Lists;
 
 namespace DataStructures.Graphs
 {
-    /// <summary>
-    /// The Dense Graph Data Structure.
-    /// 
-    /// Definition:
-    /// A dense graph is a graph G = (V, E) in which |E| = O(|V|^2).
-    /// 
-    /// This class represents the graph as an incidence-matrix (two dimensional boolean array).
-    /// </summary>
     public class UndirectedDenseGraph<T> : IGraph<T> where T : IComparable<T>
     {
         /// <summary>

DataStructures/Graphs/UndirectedSparseGraph.cs

@@ -1,18 +1,19 @@
-using System;
+/***
+ * The Sparse Graph Data Structure.
+ * Definition: A sparse graph is a graph G = (V, E) in which |E| = O(|V|).
+ * 
+ * An adjacency-list graph representation. Implemented using a Dictionary. The nodes are inserted as keys, 
+ * and the neighbors of every node are implemented as a doubly-linked list of nodes. 
+ * This class implements the IGraph<T> interface.
+ */
+
+using System;
 using System.Collections.Generic;
 
 using DataStructures.Lists;
 
 namespace DataStructures.Graphs
 {
-    /// <summary>
-    /// The Sparse Graph Data Structure.
-    /// 
-    /// Definition:
-    /// A sparse graph is a graph G = (V, E) in which |E| = O(|V|).
-    /// 
-    /// This class represents the graph as an adjacency list (dictionary).
-    /// </summary>
     public class UndirectedSparseGraph<T> : IGraph<T> where T : IComparable<T>
     {
         /// <summary>

DataStructures/Hashing/PrimeHashingFamily.cs

@@ -1,4 +1,12 @@
-using System;
+/***
+ * Prime-Hashing Functions Family.
+ * 
+ * Implements a simple family of hash functions using primes. 
+ * The functions are initialized by randomly selecting primes. 
+ * Supports re-generation of functions.
+ */
+
+using System;
 
 using DataStructures.Common;
 using DataStructures.Lists;

DataStructures/Hashing/UniversalHashingFamily.cs

@@ -1,4 +1,14 @@
-using System;
+/***
+ * Universal-Hashing Functions Family.
+ * 
+ * Implements a family class of simple universal-hashing functions. 
+ * Supports re-generation of functions. 
+ * It depends on the Common/PrimesList helper class. 
+ * 
+ * This class is used in the Cuckoo Hash Table implementation.
+ */
+
+using System;
 
 using DataStructures.Common;
 using DataStructures.Lists;

MainProgram/Program.cs

@@ -12,19 +12,7 @@ public class Program
     {
         public static void Main(string[] args)
         {
-            string input = "2-4+5*6-1";
-
-			var result = input.Split(new char[] { '-', '+', '*' }).ToList()
-				.Select<string, int>(item => Convert.ToInt32(item))
-				.ToList<int>();
-
-			var ops = new List<char>();
-
-			for(int i = 0; i < input.Length; i++) {
-				if(input[i] == '+' || input[i] == '-' || input[i] == '*') {
-					ops.Add (input [i]);
-				}
-			}
+            
         }
     }
 }