Small tweaks to text

Author: hollance

Breadth-First Search/BreadthFirstSearch.playground/Pages/Simple example.xcplaygroundpage/Contents.swift

@@ -12,7 +12,6 @@ func breadthFirstSearch(graph: Graph, source: Node) -> [String] {
       if !neighborNode.visited {
         queue.enqueue(neighborNode)
         neighborNode.visited = true
-
         nodesExplored.append(neighborNode.label)
       }
     }

Breadth-First Search/BreadthFirstSearch.swift

@@ -12,7 +12,6 @@ func breadthFirstSearch(graph: Graph, source: Node) -> [String] {
       if !neighborNode.visited {
         queue.enqueue(neighborNode)
         neighborNode.visited = true
-
         nodesExplored.append(neighborNode.label)
       }
     }

Breadth-First Search/README.markdown

@@ -1,6 +1,6 @@
 # Breadth-First Search
 
-Breadth-first search (BFS) is an algorithm for traversing or searching [tree](../Tree/) or [graph](../Graph/) data structures. It starts at the tree source and explores the neighbor nodes first, before moving to the next level neighbors.
+Breadth-first search (BFS) is an algorithm for traversing or searching [tree](../Tree/) or [graph](../Graph/) data structures. It starts at the tree source and explores the immediate neighbor nodes first, before moving to the next level neighbors.
 
 ## Animated example
 
@@ -9,49 +9,67 @@ Breadth-first search (BFS) is an algorithm for traversing or searching [tree](..
 Let's follow the animated example by using a [queue](../Queue/).
 
 Start with the source node ``a`` and add it to a queue.
+
 ```swift
 queue.enqueue(a)
 ```
-The queue is now ``[ a ]``. Dequeue ``a`` and enqueue the neighbor nodes ``b`` and ``c``.
+
+The queue is now ``[ a ]``. Dequeue ``a`` and enqueue its two neighbor nodes ``b`` and ``c``.
+
 ```swift
-queue.dequeue(a)
+queue.dequeue()   // a
 queue.enqueue(b)
 queue.enqueue(c)
 ```
-The queue is now ``[ b, c ]``. Dequeue ``b`` and enqueue the neighbor nodes ``d`` and ``e``.
+
+The queue is now ``[ b, c ]``. Dequeue ``b`` and enqueue `b`'s neighbor nodes ``d`` and ``e``.
+
 ```swift
-queue.dequeue(b)
+queue.dequeue()   // b
 queue.enqueue(d)
 queue.enqueue(e)
 ```
-The queue is now ``[ c, d, e ]``. Dequeue ``c`` and enqueue the neighbor nodes ``f`` and ``g``.
+
+The queue is now ``[ c, d, e ]``. Dequeue ``c`` and enqueue `c`'s neighbor nodes ``f`` and ``g``.
+
 ```swift
-queue.dequeue(c)
+queue.dequeue()   // c
 queue.enqueue(f)
 queue.enqueue(g)
 ```
+
 The queue is now ``[ d, e, f, g ]``. Dequeue ``d`` which has no neighbor nodes.
+
 ```swift
-queue.dequeue(d)
+queue.dequeue()   // d
 ```
-The queue is now ``[ e, f, g ]``. Dequeue ``e`` and enqueue the single neighbor node ``h``.
+
+The queue is now ``[ e, f, g ]``. Dequeue ``e`` and enqueue its single neighbor node ``h``.
+
 ```swift
-queue.dequeue(e)
+queue.dequeue()   // e
 queue.enqueue(h)
 ```
+
 The queue is now ``[ f, g, h ]``. Dequeue ``f`` which has no neighbor nodes.
+
 ```swift
-queue.dequeue(f)
+queue.dequeue()   // f
 ```
+
 The queue is now ``[ g, h ]``. Dequeue ``g`` which has no neighbor nodes.
+
 ```swift
-queue.dequeue(g)
+queue.dequeue()   // g
 ```
+
 The queue is now ``[ h ]``. Dequeue ``h`` which has no neighbor nodes.
+
 ```swift
-queue.dequeue(h)
+queue.dequeue()   // h
 ```
-The queue is now empty which means all nodes have been explored.
+
+The queue is now empty, meaning that all nodes have been explored. The order in which the nodes were explored is `a`, `b`, `c`, `d`, `e`, `f`, `g`, `h`.
 
 ## The code
 
@@ -72,7 +90,6 @@ func breadthFirstSearch(graph: Graph, source: Node) -> [String] {
       if !neighborNode.visited {
         queue.enqueue(neighborNode)
         neighborNode.visited = true
-
         nodesExplored.append(neighborNode.label)
       }
     }
@@ -83,8 +100,9 @@ func breadthFirstSearch(graph: Graph, source: Node) -> [String] {
 ```
 
 Put this code in a playground and test it like so:
+
 ```swift
-let graph = Graph() // Representing the graph from the animated example
+let graph = Graph()   // Representing the graph from the animated example
 
 let nodeA = graph.addNode("a")
 let nodeB = graph.addNode("b")
@@ -104,46 +122,53 @@ graph.addEdge(nodeC, neighbor: nodeG)
 graph.addEdge(nodeE, neighbor: nodeH)
 
 let nodesExplored = breadthFirstSearch(graph, source: nodeA)
-print(nodesExplored) // This will output: ["a", "b", "c", "d", "e", "f", "g", "h"]
+print(nodesExplored)
 ```
 
+This will output: `["a", "b", "c", "d", "e", "f", "g", "h"]`
+   
 ## Applications
 
 Breadth-first search can be used to solve many problems, for example:
 
-* Computing the shortest path between a source node and each of the other nodes
-  * Only for unweighted graphs
+* Computing the shortest path between a source node and each of the other nodes (only for unweighted graphs)
 * Calculating the minimum spanning tree on an unweighted graph
 
 ## Shortest path example
 
-Breadth-first search can be used to compute the [shortest path](../Shortest Path/) between a source node and each of the other nodes because it explores all of the neighbor nodes before moving to the next level neighbors. Let's follow the animated example and calculate the shortest path to all the other nodes:
+Breadth-first search can be used to compute the [shortest path](../Shortest Path/) between a source node and each of the other nodes in the tree or graph, because it explores all of the immediate neighbor nodes first before moving to the next level neighbors.
+
+Let's follow the animated example and calculate the shortest path to all the other nodes. Start with the source node ``a`` and add it to a queue with a distance of ``0``.
 
-Start with the source node ``a`` and add it to a queue with a distance of ``0``.
 ```swift
 queue.enqueue(a)
 a.distance = 0
 ```
-The queue is now ``[ a ]``. Dequeue ``a`` and enqueue the neighbor nodes ``b`` and ``c`` with a distance of ``1``.
+
+The queue is now ``[ a ]``. Dequeue ``a`` and enqueue its two neighbor nodes ``b`` and ``c`` with a distance of ``1``.
+
 ```swift
-queue.dequeue(a)
+queue.dequeue()   // a
 queue.enqueue(b)
-b.distance = a.distance + 1 // result: 1
+b.distance = a.distance + 1   // result: 1
 queue.enqueue(c)
-c.distance = a.distance + 1 // result: 1
+c.distance = a.distance + 1   // result: 1
 ```
-The queue is now ``[ b, c ]``. Dequeue ``b`` and enqueue the neighbor nodes ``d`` and ``e`` with a distance of ``2``.
+
+The queue is now ``[ b, c ]``. Dequeue ``b`` and enqueue `b`'s neighbor nodes ``d`` and ``e`` with a distance of ``2``.
+
 ```swift
-queue.dequeue(b)
+queue.dequeue()   // b
 queue.enqueue(d)
-d.distance = b.distance + 1 // result: 2
+d.distance = b.distance + 1   // result: 2
 queue.enqueue(e)
-e.distance = b.distance + 1 // result: 2
+e.distance = b.distance + 1   // result: 2
 ```
 
 Continue until the queue is empty to calculate the shortest path to all other nodes.
 
 Here's the code:
+
 ```swift
 func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
   let shortestPathGraph = graph.duplicate()
@@ -169,19 +194,21 @@ func breadthFirstSearchShortestPath(graph: Graph, source: Node) -> Graph {
 ```
 
 Put this code in a playground and test it like so:
+
 ```swift
 let shortestPathGraph = breadthFirstSearchShortestPath(graph, source: nodeA)
 print(shortestPathGraph.nodes)
-
-// This will output:
-// Node(label: a, distance: 0), Node(label: b, distance: 1), Node(label: c, distance: 1),
-// Node(label: d, distance: 2), Node(label: e, distance: 2), Node(label: f, distance: 2),
-// Node(label: g, distance: 2), Node(label: h, distance: 3)
 ```
 
+This will output:
+
+	Node(label: a, distance: 0), Node(label: b, distance: 1), Node(label: c, distance: 1),
+	Node(label: d, distance: 2), Node(label: e, distance: 2), Node(label: f, distance: 2),
+	Node(label: g, distance: 2), Node(label: h, distance: 3)
+
 ## Minimum spanning tree example
 
-Breadth-first search can be used to calculate the [minimum spanning tree](../Minimum Spanning Tree/) on an unweighted graph.
+Breadth-first search can be used to calculate the [minimum spanning tree](../Minimum Spanning Tree/) on an unweighted graph. A minimum spanning tree describes a path that contains the smallest number of edges that are needed to visit every node in the graph.
 
 Let's calculate the minimum spanning tree for the following graph:
 
@@ -190,71 +217,92 @@ Let's calculate the minimum spanning tree for the following graph:
 *Note: the minimum spanning tree is represented by the bold edges.*
 
 Start with the source node ``a`` and add it to a queue and mark it as visited.
+
 ```swift
 queue.enqueue(a)
 a.visited = true
 ```
-The queue is now ``[ a ]``. Dequeue ``a`` and enqueue the neighbor nodes ``b`` and ``h`` and mark them as visited.
+
+The queue is now ``[ a ]``. Dequeue ``a`` and enqueue its immediate neighbor nodes ``b`` and ``h`` and mark them as visited.
+
 ```swift
-queue.dequeue(a)
+queue.dequeue()   // a
 queue.enqueue(b)
 b.visited = true
 queue.enqueue(h)
 h.visited = true
 ```
+
 The queue is now ``[ b, h ]``. Dequeue ``b`` and enqueue the neighbor node ``c`` mark it as visited. Remove the edge between ``b`` to ``h`` because ``h`` has already been visited.
+
 ```swift
-queue.dequeue(b)
+queue.dequeue()   // b
 queue.enqueue(c)
 c.visited = true
 b.removeEdgeTo(h)
 ```
+
 The queue is now ``[ h, c ]``. Dequeue ``h`` and enqueue the neighbor nodes ``g`` and ``i`` and mark them as visited.
+
 ```swift
-queue.dequeue(h)
+queue.dequeue()   // h
 queue.enqueue(g)
 g.visited = true
 queue.enqueue(i)
 i.visited = true
 ```
+
 The queue is now ``[ c, g, i ]``. Dequeue ``c`` and enqueue the neighbor nodes ``d`` and ``f`` and mark them as visited. Remove the edge between ``c`` to ``i`` because ``i`` has already been visited.
+
 ```swift
-queue.dequeue(c)
+queue.dequeue()   // c
 queue.enqueue(d)
 d.visited = true
 queue.enqueue(f)
 f.visited = true
 c.removeEdgeTo(i)
 ```
+
 The queue is now ``[ g, i, d, f ]``. Dequeue ``g`` and remove the edges between ``g`` to ``f`` and ``g`` to ``i`` because ``f`` and ``i`` have already been visited.
+
 ```swift
-queue.dequeue(g)
+queue.dequeue()   // g
 g.removeEdgeTo(f)
 g.removeEdgeTo(i)
 ```
+
 The queue is now ``[ i, d, f ]``. Dequeue ``i``.
+
 ```swift
-queue.dequeue(i)
+queue.dequeue()   // i
 ```
+
 The queue is now ``[ d, f ]``. Dequeue ``d`` and enqueue the neighbor node ``e`` mark it as visited. Remove the edge between ``d`` to ``f`` because ``f`` has already been visited.
+
 ```swift
-queue.dequeue(d)
+queue.dequeue()   // d
 queue.enqueue(e)
 e.visited = true
 d.removeEdgeTo(f)
 ```
+
 The queue is now ``[ f, e ]``. Dequeue ``f``. Remove the edge between ``f`` to ``e`` because ``e`` has already been visited.
+
 ```swift
-queue.dequeue(f)
+queue.dequeue()   // f
 f.removeEdgeTo(e)
 ```
+
 The queue is now ``[ e ]``. Dequeue ``e``.
+
 ```swift
-queue.dequeue(e)
+queue.dequeue()   // e
 ```
-The queue is now empty which means the minimum spanning tree has been computed.
+
+The queue is now empty, which means the minimum spanning tree has been computed.
 
 Here's the code:
+
 ```swift
 func breadthFirstSearchMinimumSpanningTree(graph: Graph, source: Node) -> Graph {
   let minimumSpanningTree = graph.duplicate()
@@ -280,7 +328,11 @@ func breadthFirstSearchMinimumSpanningTree(graph: Graph, source: Node) -> Graph
   return minimumSpanningTree
 }
 ```
+
+This function returns a new `Graph` object that describes just the minimum spanning tree. In the figure, that would be the graph containing just the bold edges.
+
 Put this code in a playground and test it like so:
+
 ```swift
 let graph = Graph()
 
@@ -331,6 +383,7 @@ print(minimumSpanningTree) // [node: a edges: ["b", "h"]]
                            // [node: d edges: ["e"]]
                            // [node: h edges: ["g", "i"]]
 ```
+
 ## See also
 
 [Graph](../Graph/), [Tree](../Tree/), [Queues](../Queue/), [Shortest Path](../Shortest Path/), [Minimum Spanning Tree](../Minimum Spanning Tree/).