$ => and

justcoding121 · justcoding121 · commit 1da8c60a420e · 2018-08-08T10:11:35.000-04:00
diff --git a/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/DiGraph.cs b/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/DiGraph.cs
@@ -114,7 +114,7 @@ public void AddEdge(T source, T dest)
         }
 
         /// <summary>
-        /// Remove an existing edge between source & destination.
+        /// Remove an existing edge between source and destination.
         /// Time complexity: O(1).
         /// </summary>
         public void RemoveEdge(T source, T dest)
diff --git a/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/Graph.cs b/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/Graph.cs
@@ -62,7 +62,6 @@ public GraphVertex<T> AddVertex(T value)
         /// Remove an existing vertex from this graph.
         /// Time complexity: O(V) where V is the number of vertices.
         /// </summary>
-        /// <param name="vertex"></param>
         public void RemoveVertex(T vertex)
         {
             if (vertex == null)
diff --git a/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/DiGraph.cs b/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/DiGraph.cs
@@ -74,7 +74,6 @@ public void AddVertex(T value)
         /// Remove an existing vertex from graph
         /// Time complexity: O(V) where V is the number of vertices.
         /// </summary>
-        /// <param name="value"></param>
         public void RemoveVertex(T value)
         {
             if (value == null)
@@ -112,8 +111,6 @@ public void RemoveVertex(T value)
         /// add an edge from source to destination vertex
         /// Time complexity: O(1).
         /// </summary>
-        /// <param name="source"></param>
-        /// <param name="dest"></param>
         public void AddEdge(T source, T dest)
         {
             if (source == null || dest == null)
@@ -137,7 +134,7 @@ public void AddEdge(T source, T dest)
         }
 
         /// <summary>
-        /// remove an existing edge between source & destination
+        /// remove an existing edge between source and destination
         /// Time complexity: O(1).
         /// </summary>
         public void RemoveEdge(T source, T dest)
diff --git a/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/Graph.cs b/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/Graph.cs
@@ -136,7 +136,7 @@ public void AddEdge(T source, T dest)
         }
 
         /// <summary>
-        /// Remove an existing edge between source & destination.
+        /// Remove an existing edge between source and destination.
         /// Time complexity: O(1).
         /// </summary>
         public void RemoveEdge(T source, T dest)
diff --git a/Advanced.Algorithms/DataStructures/Heap/Max/BinomialMaxHeap.cs b/Advanced.Algorithms/DataStructures/Heap/Max/BinomialMaxHeap.cs
@@ -184,7 +184,7 @@ private void meld()
                     cur = next;
                     next = cur.Next;
                 }
-                //degress of cur & next are same
+                //degress of cur and next are same
                 else
                 {
                     //case 2 next degree equals next-next degree
diff --git a/Advanced.Algorithms/DataStructures/Heap/Max/FibornacciMaxHeap.cs b/Advanced.Algorithms/DataStructures/Heap/Max/FibornacciMaxHeap.cs
@@ -291,7 +291,6 @@ private void cut(FibornacciHeapNode<T> node)
         /// <summary>
         /// Merges the given fibornacci node list to current Forest 
         /// </summary>
-        /// <param name="headPointer"></param>
         private void mergeForests(FibornacciHeapNode<T> headPointer)
         {
             var current = headPointer;
diff --git a/Advanced.Algorithms/DataStructures/Heap/Min/BinomialMinHeap.cs b/Advanced.Algorithms/DataStructures/Heap/Min/BinomialMinHeap.cs
@@ -184,7 +184,7 @@ private void meld()
                     cur = next;
                     next = cur.Next;
                 }
-                //degress of cur & next are same
+                //degress of cur and next are same
                 else
                 {
                     //case 2 next degree equals next-next degree
@@ -228,7 +228,7 @@ private void meld()
 
         /// <summary>
         /// Merges the given sorted forest to current sorted Forest 
-        /// & returns the last inserted node (pointer required for decrement-key)
+        /// and returns the last inserted node (pointer required for decrement-key)
         /// </summary>
         private void mergeSortedForests(DoublyLinkedList<BinomialHeapNode<T>> newHeapForest)
         {
diff --git a/Advanced.Algorithms/DataStructures/Heap/Min/FibornacciMinHeap.cs b/Advanced.Algorithms/DataStructures/Heap/Min/FibornacciMinHeap.cs
@@ -288,7 +288,6 @@ private void cut(FibornacciHeapNode<T> node)
         /// <summary>
         /// Merges the given fibornacci node list to current Forest 
         /// </summary>
-        /// <param name="headPointer"></param>
         private void mergeForests(FibornacciHeapNode<T> headPointer)
         {
             var current = headPointer;
diff --git a/Advanced.Algorithms/DataStructures/Tree/B+Tree.cs b/Advanced.Algorithms/DataStructures/Tree/B+Tree.cs
@@ -183,7 +183,7 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,
             //and insert new median to parent
             if (node.KeyCount == maxKeysPerNode)
             {
-                //divide the current node values + new Node as left & right sub nodes
+                //divide the current node values + new Node as left and right sub nodes
                 var left = new BpTreeNode<T>(maxKeysPerNode, null);
                 var right = new BpTreeNode<T>(maxKeysPerNode, null);
 
@@ -227,7 +227,7 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,
                 var insertionCount = 0;
 
                 //insert newValue and existing values in sorted order
-                //to left & right nodes
+                //to left and right nodes
                 //set new median during sorting
                 for (var i = 0; i < node.KeyCount; i++)
                 {
@@ -276,8 +276,8 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,
 
                     }
 
-                    //pick the smaller among newValue & node.Keys[i]
-                    //and insert in to currentNode (left & right nodes)
+                    //pick the smaller among newValue and node.Keys[i]
+                    //and insert in to currentNode (left and right nodes)
                     //if new Value was already inserted then just copy from node.Keys in sequence
                     //since node.Keys is already in sorted order it should be fine
                     if (newValueInserted || node.Keys[i].CompareTo(newValue) < 0)
@@ -543,7 +543,7 @@ private void sandwich(BpTreeNode<T> leftSibling, BpTreeNode<T> rightSibling, T d
 
             var newNode = new BpTreeNode<T>(maxKeysPerNode, leftSibling.Parent);
 
-            //if leaves are merged then update the Next & Prev pointers
+            //if leaves are merged then update the Next and Prev pointers
             if (leftSibling.IsLeaf)
             {
                 if (leftSibling.Prev != null)
@@ -943,7 +943,7 @@ internal BpTreeNode(int maxKeysPerNode, BpTreeNode<T> parent)
         }
 
         /// <summary>
-        /// For shared test method accross B & B+ tree
+        /// For shared test method accross B and B+ tree
         /// </summary>
         /// <returns></returns>
         internal override BNode<T> GetParent()
@@ -952,7 +952,7 @@ internal override BNode<T> GetParent()
         }
 
         /// <summary>
-        /// For shared test method accross B & B+ tree
+        /// For shared test method accross B and B+ tree
         /// </summary>
         /// <returns></returns>
         internal override BNode<T>[] GetChildren()
diff --git a/Advanced.Algorithms/DataStructures/Tree/BST.cs b/Advanced.Algorithms/DataStructures/Tree/BST.cs
@@ -364,8 +364,6 @@ private BSTNodeBase<T> find(T value)
         ///     Get the value previous to given value in this BST.
         ///     Time complexity: O(n)
         /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
         public T NextLower(T value)
         {
             var node = find(value);
diff --git a/Advanced.Algorithms/DataStructures/Tree/BTree.cs b/Advanced.Algorithms/DataStructures/Tree/BTree.cs
@@ -182,7 +182,7 @@ private void insertAndSplit(ref BTreeNode<T> node, T newValue,
             //and insert new median to parent
             if (node.KeyCount == maxKeysPerNode)
             {
-                //divide the current node values + new Node as left & right sub nodes
+                //divide the current node values + new Node as left and right sub nodes
                 var left = new BTreeNode<T>(maxKeysPerNode, null);
                 var right = new BTreeNode<T>(maxKeysPerNode, null);
 
@@ -202,7 +202,7 @@ private void insertAndSplit(ref BTreeNode<T> node, T newValue,
                 var insertionCount = 0;
 
                 //insert newValue and existing values in sorted order
-                //to left & right nodes
+                //to left and right nodes
                 //set new median during sorting
                 for (var i = 0; i < node.KeyCount; i++)
                 {
@@ -251,8 +251,8 @@ private void insertAndSplit(ref BTreeNode<T> node, T newValue,
 
                     }
 
-                    //pick the smaller among newValue & node.Keys[i]
-                    //and insert in to currentNode (left & right nodes)
+                    //pick the smaller among newValue and node.Keys[i]
+                    //and insert in to currentNode (left and right nodes)
                     //if new Value was already inserted then just copy from node.Keys in sequence
                     //since node.Keys is already in sorted order it should be fine
                     if (newValueInserted || node.Keys[i].CompareTo(newValue) < 0)
@@ -757,8 +757,8 @@ public IEnumerator<T> GetEnumerator()
     }
 
     /// <summary>
-    /// abstract node shared by both B & B+ tree nodes
-    /// so that we can use this for common tests across B & B+ tree
+    /// abstract node shared by both B and B+ tree nodes
+    /// so that we can use this for common tests across B and B+ tree
     /// </summary>
     internal abstract class BNode<T> where T : IComparable
     {
@@ -770,7 +770,7 @@ internal abstract class BNode<T> where T : IComparable
         internal T[] Keys { get; set; }
         internal int KeyCount;
 
-        //for common unit testing across B & B+ tree
+        //for common unit testing across B and B+ tree
         internal abstract BNode<T> GetParent();
         internal abstract BNode<T>[] GetChildren();
 
@@ -803,15 +803,15 @@ internal BTreeNode(int maxKeysPerNode, BTreeNode<T> parent)
         }
 
         /// <summary>
-        /// For shared test method accross B & B+ tree
+        /// For shared test method accross B and B+ tree
         /// </summary>
         internal override BNode<T> GetParent()
         {
             return Parent;
         }
 
         /// <summary>
-        /// For shared test method accross B & B+ tree
+        /// For shared test method accross B and B+ tree
         /// </summary>
         internal override BNode<T>[] GetChildren()
         {
diff --git a/Advanced.Algorithms/DataStructures/Tree/K_DTree.cs b/Advanced.Algorithms/DataStructures/Tree/K_DTree.cs
@@ -436,7 +436,7 @@ private List<T[]> rangeSearch(List<T[]> result,
         }
 
         /// <summary>
-        /// Is the point in node is within start & end points.
+        /// Is the point in node is within start and end points.
         /// </summary>
         private bool inRange(KDTreeNode<T> node, T[] start, T[] end)
         {
diff --git a/Advanced.Algorithms/DataStructures/Tree/RangeTree.cs b/Advanced.Algorithms/DataStructures/Tree/RangeTree.cs
@@ -53,7 +53,6 @@ public void Insert(T[] value)
         /// <summary>
         /// Time complexity: O(n).
         /// </summary>
-        /// <param name="value"></param>
         public void Delete(T[] value)
         {
             validateDimensions(value);
@@ -310,7 +309,7 @@ private List<RangeTreeNode<T>> getInRange(List<RangeTreeNode<T>> result, Diction
         /// </summary>
         private bool inRange(RedBlackTreeNode<RangeTreeNode<T>> currentNode, T start, T end)
         {
-            //start is less than current & end is greater than current
+            //start is less than current and end is greater than current
             return start.CompareTo(currentNode.Value.Value) <= 0
                 && end.CompareTo(currentNode.Value.Value) >= 0;
         }
diff --git a/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs b/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs
@@ -705,8 +705,6 @@ private RedBlackTreeNode<T> handleDoubleBlack(RedBlackTreeNode<T> node)
         /// <summary>
         ///     Get the value previous to given value in this BST.
         /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
         public T NextLower(T value)
         {
             var node = FindNode(value);
@@ -722,8 +720,6 @@ public T NextLower(T value)
         /// <summary>
         ///     Get the value next to given value in this BST.
         /// </summary>
-        /// <param name="value"></param>
-        /// <returns></returns>
         public T NextHigher(T value)
         {
             var node = FindNode(value);
diff --git a/Advanced.Algorithms/DataStructures/Tree/TernarySearchTree.cs b/Advanced.Algorithms/DataStructures/Tree/TernarySearchTree.cs
@@ -87,7 +87,6 @@ private void insert(ref TernarySearchTreeNode<T> currentNode,
         /// Deletes a record from this ternary search tree.
         /// Time complexity: O(m) where m is the length of entry.
         /// </summary>
-        /// <param name="entry"></param>
         public void Delete(T[] entry)
         {
             delete(root, entry, 0);
diff --git a/Advanced.Algorithms/DataStructures/Tree/TreapTree.cs b/Advanced.Algorithms/DataStructures/Tree/TreapTree.cs
@@ -381,8 +381,6 @@ private TreapTreeNode<T> rightRotate(TreapTreeNode<T> currentRoot)
         /// <summary>
         /// Rotates the current root left and returns new root
         /// </summary>
-        /// <param name="currentRoot"></param>
-        /// <returns></returns>
         private TreapTreeNode<T> leftRotate(TreapTreeNode<T> currentRoot)
         {
             var prevRoot = currentRoot;
diff --git a/Advanced.Algorithms/Distributed/AsyncQueue.cs b/Advanced.Algorithms/Distributed/AsyncQueue.cs
@@ -12,7 +12,7 @@ internal class AsyncQueue<T>
         //data queue.
         private readonly Queue<T> queue = new Queue<T>();
 
-        //consumer task queue & lock.
+        //consumer task queue and lock.
         private readonly Queue<TaskCompletionSource<T>> consumerQueue = new Queue<TaskCompletionSource<T>>();
         private SemaphoreSlim consumerQueueLock = new SemaphoreSlim(1);
 
diff --git a/Advanced.Algorithms/Geometry/LineIntersection.cs b/Advanced.Algorithms/Geometry/LineIntersection.cs
@@ -97,7 +97,7 @@ internal static Point FindIntersection(Line lineA, Line lineB, double tolerance)
             //=> -m1x1 + y1 = c1 ----(1)
             //assume equation of line 2 as y2 = m2x2 + c2
             //=> -m2x2 + y2 = c2 -----(2)
-            //if line 1 and 2 intersect then x1=x2=x & y1=y2=y where (x,y) is the intersection point
+            //if line 1 and 2 intersect then x1=x2=x and y1=y2=y where (x,y) is the intersection point
             //so we will get below two equations 
             //-m1x + y = c1 --------(3)
             //-m2x + y = c2 --------(4)
@@ -136,7 +136,7 @@ internal static Point FindIntersection(Line lineA, Line lineB, double tolerance)
                 x = x3;
                 y = c1 + m1 * x3;
             }
-            //lineA & lineB are not vertical 
+            //lineA and lineB are not vertical 
             //(could be horizontal we can handle it with slope = 0)
             else
             {
@@ -148,13 +148,13 @@ internal static Point FindIntersection(Line lineA, Line lineB, double tolerance)
                 double m2 = (y4 - y3) / (x4 - x3);
                 double c2 = -m2 * x3 + y3;
 
-                //solving equations (3) & (4) => x = (c1-c2)/(m2-m1)
+                //solving equations (3) and (4) => x = (c1-c2)/(m2-m1)
                 //plugging x value in equation (4) => y = c2 + m2 * x
                 x = (c1 - c2) / (m2 - m1);
                 y = c2 + m2 * x;
 
                 //verify by plugging intersection point (x, y)
-                //in orginal equations (1) & (2) to see if they intersect
+                //in orginal equations (1) and (2) to see if they intersect
                 //otherwise x,y values will not be finite and will fail this check
                 if (!(Math.Abs(-m1 * x + y - c1) < tolerance
                     && Math.Abs(-m2 * x + y - c2) < tolerance))
diff --git a/Advanced.Algorithms/Graph/Flow/EdmondsKarp.cs b/Advanced.Algorithms/Graph/Flow/EdmondsKarp.cs
@@ -7,7 +7,7 @@ namespace Advanced.Algorithms.Graph
 
     /// <summary>
     /// An Edmond Karp max flow implementation on weighted directed graph using 
-    /// adjacency list representation of graph & residual graph.
+    /// adjacency list representation of graph and residual graph.
     /// </summary>
     public class EdmondKarpMaxFlow<T, W> where W : IComparable
     {
diff --git a/Advanced.Algorithms/Graph/Flow/FordFulkerson.cs b/Advanced.Algorithms/Graph/Flow/FordFulkerson.cs
@@ -6,7 +6,7 @@ namespace Advanced.Algorithms.Graph
 {
     /// <summary>
     /// A ford-fulkerson max flox implementation on weighted directed graph using 
-    /// adjacency list representation of graph & residual graph.
+    /// adjacency list representation of graph and residual graph.
     /// </summary>
     public class FordFulkersonMaxFlow<T, W> where W : IComparable
     {
diff --git a/Advanced.Algorithms/Graph/Flow/PushRelabel.cs b/Advanced.Algorithms/Graph/Flow/PushRelabel.cs
@@ -26,7 +26,7 @@ public W ComputeMaxFlow(WeightedDiGraph<T, W> graph,
             //clone to create a residual graph
             var residualGraph = createResidualGraph(graph);
 
-            //init vertex Height & Overflow object (ResidualGraphVertexStatus)
+            //init vertex Height and Overflow object (ResidualGraphVertexStatus)
             var vertexStatusMap = new Dictionary<T, ResidualGraphVertexStatus>();
             foreach(var vertex in residualGraph.Vertices)
             {
@@ -118,7 +118,7 @@ private bool push(WeightedDiGraphVertex<T, W> overflowVertex,
 
             foreach(var edge in overflowVertex.OutEdges)
             {
-                //if out edge has +ive weight & neighbour height is less then flow is possible
+                //if out edge has +ive weight and neighbour height is less then flow is possible
                 if(edge.Value.CompareTo(operators.defaultWeight) > 0
                     && vertexStatusMap[edge.Key.Value].Height 
                        < vertexStatusMap[overflowVertex.Value].Height)
@@ -197,7 +197,7 @@ private WeightedDiGraph<T, W> createResidualGraph(WeightedDiGraph<T, W> graph)
         }
 
         /// <summary>
-        /// An object to keep track of Vertex Overflow & Height.
+        /// An object to keep track of Vertex Overflow and Height.
         /// </summary>
         internal class ResidualGraphVertexStatus
         {
diff --git a/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs b/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs
@@ -73,7 +73,7 @@ private List<MatchEdge<T>> getMaxBiPartiteMatching(Graph<T> graph,
         }
 
         /// <summary>
-        /// create a directed unit weighted graph with given dummySource to Patition 1 & Patition 2 to dummy sink.
+        /// create a directed unit weighted graph with given dummySource to Patition 1 and Patition 2 to dummy sink.
         /// </summary>
         private static WeightedDiGraph<T, int> createFlowGraph(Graph<T> graph,
             T dummySource, T dummySink,
diff --git a/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs b/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs
@@ -46,7 +46,7 @@ public List<MSTEdge<T, TW>>
             }
 
             //pick each edge one by one
-            //if both source & target belongs to same set 
+            //if both source and target belongs to same set 
             //then don't add the edge to result
             //otherwise add it to result and union sets
             for (int i = 0; i < edges.Count; i++)
diff --git a/Advanced.Algorithms/Sorting/CountingSort.cs b/Advanced.Algorithms/Sorting/CountingSort.cs
diff --git a/Advanced.Algorithms/Sorting/TreeSort.cs b/Advanced.Algorithms/Sorting/TreeSort.cs
diff --git a/Advanced.Algorithms/String/Search/ZAlgorithm.cs b/Advanced.Algorithms/String/Search/ZAlgorithm.cs

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ public void AddEdge(T source, T dest)`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`/// <summary>`
`117`		`- /// Remove an existing edge between source & destination.`
	`117`	`+ /// Remove an existing edge between source and destination.`
`118`	`118`	`/// Time complexity: O(1).`
`119`	`119`	`/// </summary>`
`120`	`120`	`public void RemoveEdge(T source, T dest)`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,6 @@ public GraphVertex<T> AddVertex(T value)`
`62`	`62`	`/// Remove an existing vertex from this graph.`
`63`	`63`	`/// Time complexity: O(V) where V is the number of vertices.`
`64`	`64`	`/// </summary>`
`65`		`- /// <param name="vertex"></param>`
`66`	`65`	`public void RemoveVertex(T vertex)`
`67`	`66`	`{`
`68`	`67`	`if (vertex == null)`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public void AddEdge(T source, T dest)`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`/// <summary>`
`139`		`- /// Remove an existing edge between source & destination.`
	`139`	`+ /// Remove an existing edge between source and destination.`
`140`	`140`	`/// Time complexity: O(1).`
`141`	`141`	`/// </summary>`
`142`	`142`	`public void RemoveEdge(T source, T dest)`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ private void meld()`
`184`	`184`	`cur = next;`
`185`	`185`	`next = cur.Next;`
`186`	`186`	`}`
`187`		`- //degress of cur & next are same`
	`187`	`+ //degress of cur and next are same`
`188`	`188`	`else`
`189`	`189`	`{`
`190`	`190`	`//case 2 next degree equals next-next degree`
Original file line number	Diff line number	Diff line change
`@@ -291,7 +291,6 @@ private void cut(FibornacciHeapNode<T> node)`
`291`	`291`	`/// <summary>`
`292`	`292`	`/// Merges the given fibornacci node list to current Forest`
`293`	`293`	`/// </summary>`
`294`		`- /// <param name="headPointer"></param>`
`295`	`294`	`private void mergeForests(FibornacciHeapNode<T> headPointer)`
`296`	`295`	`{`
`297`	`296`	`var current = headPointer;`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,6 @@ private void cut(FibornacciHeapNode<T> node)`
`288`	`288`	`/// <summary>`
`289`	`289`	`/// Merges the given fibornacci node list to current Forest`
`290`	`290`	`/// </summary>`
`291`		`- /// <param name="headPointer"></param>`
`292`	`291`	`private void mergeForests(FibornacciHeapNode<T> headPointer)`
`293`	`292`	`{`
`294`	`293`	`var current = headPointer;`
Original file line number	Diff line number	Diff line change
`@@ -364,8 +364,6 @@ private BSTNodeBase<T> find(T value)`
`364`	`364`	`/// Get the value previous to given value in this BST.`
`365`	`365`	`/// Time complexity: O(n)`
`366`	`366`	`/// </summary>`
`367`		`- /// <param name="value"></param>`
`368`		`- /// <returns></returns>`
`369`	`367`	`public T NextLower(T value)`
`370`	`368`	`{`
`371`	`369`	`var node = find(value);`