diff --git a/curriculum/challenges/english/08-coding-interview-prep/data-structures/breadth-first-search.english.md b/curriculum/challenges/english/08-coding-interview-prep/data-structures/breadth-first-search.english.md
index 186a1c02b1..14ac244f21 100644
--- a/curriculum/challenges/english/08-coding-interview-prep/data-structures/breadth-first-search.english.md
+++ b/curriculum/challenges/english/08-coding-interview-prep/data-structures/breadth-first-search.english.md
@@ -9,13 +9,20 @@ forumTopicId: 301622
So far, we've learned different ways of creating representations of graphs. What now? One natural question to have is what are the distances between any two nodes in the graph? Enter graph traversal algorithms.
Traversal algorithms are algorithms to traverse or visit nodes in a graph. One type of traversal algorithm is the breadth-first search algorithm.
-This algorithm starts at one node, first visits all its neighbors that are one edge away, then goes on to visiting each of their neighbors and so on until all nodes have been reached.
+This algorithm starts at one node and visits all its neighbors that are one edge away. It then goes on to visit each of their neighbors and so on until all nodes have been reached.
+
+An important data structure that will help implement the breadth-first search algorithm is the queue. This is an array where you can add elements to one end and remove elements from the other end. This is also known as a FIFO or First-In-First-Out data structure.
+
Visually, this is what the algorithm is doing.
+
+The grey shading represents a node getting added into the queue and the black shading represents a node getting removed from the queue. See how every time a node gets removed from the queue (node turns black), all their neighbors get added into the queue (node turns grey).
+
To implement this algorithm, you'll need to input a graph structure and a node you want to start at.
-First, you'll want to be aware of the distances from the start node. This you'll want to start all your distances initially some large number, like Infinity. This gives a reference for the case where a node may not be reachable from your start node.
+
+First, you'll want to be aware of the distances from, or number of edges away from, the start node. You'll want to start all your distances with some large number, like Infinity. This prevents counting issues for when a node may not be reachable from your start node.
Next, you'll want to go from the start node to its neighbors. These neighbors are one edge away and at this point you should add one unit of distance to the distances you're keeping track of.
-Last, an important data structure that will help implement the breadth-first search algorithm is the queue. This is an array where you can add elements to one end and remove elements from the other end. This is also known as a FIFO or First-In-First-Out data structure.
+
## Instructions
diff --git a/curriculum/challenges/english/08-coding-interview-prep/data-structures/depth-first-search.english.md b/curriculum/challenges/english/08-coding-interview-prep/data-structures/depth-first-search.english.md
index 8f2c35c511..4667a41a2a 100644
--- a/curriculum/challenges/english/08-coding-interview-prep/data-structures/depth-first-search.english.md
+++ b/curriculum/challenges/english/08-coding-interview-prep/data-structures/depth-first-search.english.md
@@ -10,9 +10,14 @@ forumTopicId: 301640
Similar to breadth-first search, here we will learn about another graph traversal algorithm called depth-first search.
Whereas the breadth-first search searches incremental edge lengths away from the source node, depth-first search first goes down a path of edges as far as it can.
Once it reaches one end of a path, the search will backtrack to the last node with an un-visited edge path and continue searching.
-Visually, this is what the algorithm is doing where the top node is the starting point of the search.
+The animation below shows how the algorithm works. The algorithm starts with the top node and visits the nodes in the numbered order.
-A simple output of this algorithm is a list of nodes which are reachable from a given node. So when implementing this algorithm, you'll need to keep track of the nodes you visit.
+
+Notice how, unlike breadth-first search, every time a node is visited, it doesn't visit all of its neighbors. Instead, it first visits one of its neighbors and continues down that path until there are no more nodes to be visited on that path.
+
+To implement this algorithm, you'll want to use a stack. A stack is an array where the last element added is the first to be removed. This is also known as a Last-In-First-Out data structure. A stack is helpful in depth-first search algorithms because, as we add neighbors to the stack, we want to visit the most recently added neighbors first and remove them from the stack.
+
+A simple output of this algorithm is a list of nodes which are reachable from a given node. Therefore, you'll also want to keep track of the nodes you visit.
## Instructions