Correcting queue grammar

Author: mesirendon

src/data-structures/queues/Queues.ipynb

@@ -7,13 +7,13 @@
     "[Back to Content](../../../content.md)\n",
     "\n",
     "# Queue\n",
-    "The queue data structure is a linear dynamic set of entities that are kept in a specificied sequence. It can be modified by adding entities, at one end of the structure, and removing them from the other end. Thus, a queue implements a **FIFO** policy (i.e., _first-in, first-out_). In other words, the first element added to the queue will be the first element to be removed.\n",
+    "The queue data structure is a linear dynamic set of entities in a specific sequence. It can be modified by adding entities, at one end of the structure, and removing them from the other. Thus, a queue implements a **FIFO** policy (i.e., _first-in, first-out_). In other words, the first element added to the queue will be the first element to be removed.\n",
     "\n",
-    "In the queue, elements are added at the end of the sequence, and removed at the beginning. By convention, the end is also known as _back_, _rear_, or **tail** (we will stick to this term), and the beginning is also known as _front_, or **head** (we will stick to this term).\n",
+    "In the queue, elements are added at the end of the sequence, and removed at the beginning. By convention, the end is also known as *back*, *rear*, or ***tail*** (we will stick to this term), and the beginning is known as *front* or ***head*** (we will stick to this term).\n",
     "\n",
-    "The queue has three main operation: insertion (i.e., enqueue), deletion (i.e., dequeue), and peek.\n",
+    "The queue has three main operations: insertion (i.e., enqueue), deletion (i.e., dequeue), and peek.\n",
     "\n",
-    "Unlike other structures, such as arrays or linked lists, the queue cannot be accesed via index (not even to search if the queue has a value). You would have to delete and get the element as many times as you need. However, this can be synthetically done with an auxiliary buffer to avoid modifications.\n",
+    "Unlike other structures, such as arrays or linked lists, the queue cannot be accessed via index (not even to search if the queue has a value). You would have to delete and get the element as many times as you need. However, this can be synthetically done with an auxiliary buffer to avoid modifications.\n",
     "\n",
     "![Queue](assets/queue.png)\n",
     "\n",
@@ -78,7 +78,7 @@
     "To solve this nuance we can use a Queue wrapper that keeps track of the head and tail adding and removing elements in and out of the set.\n",
     "\n",
     "## The Queue (Wrapper)\n",
-    "Let's use a basic implementation of the Queue wrapper to see how using it avoids to lose track of the head unless we actually delete an element of the queue.\n",
+    "Let's use a basic implementation of the Queue wrapper to see how using it avoids losing track of the head unless we actually delete an element of the queue.\n",
     "\n",
     "**Note:** I'll be changing the `Queue` implementation to explain better in a concise manner each operation. The full implementation of the [`QueueNode`](./QueueNode.js), the [`Queue`](./Queue.js), the [`QueueNode` and `Queue` tests](./__test__/queue.spec.js) can be checked for further analysis."
    ]
@@ -184,22 +184,22 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Again, despite of having lost the track of the nodes in the `head` variable, the queue is still intact because the wrapper has the track of the head.\n",
+    "Again, despite having lost track of the nodes in the `head` variable, the queue is still intact because the wrapper has the track of the head.\n",
     "\n",
     "## Operations\n",
     "### `queue.enqueue`\n",
-    "![Enqueue](./assets/enqueue.png)\n",
+    "![Enqueue](./enqueue.png#normal)\n",
     "\n",
-    "**Enqueue** is the insertion operation. The insertion occurs at the end of the queue. When the queue is empty the insertion add a queue node and the wrapper tracks it in the head. As the node is the only element in the queue it has been tracked in the *head* but it's also the *tail*.\n",
+    "**Enqueue** is the insertion operation. The insertion occurs at the end of the queue. When the queue is empty the insertion adds a queue node and the wrapper tracks it in the head. As the node is the only element in the queue it has been tracked in the *head* but in the *tail* as well.\n",
     "\n",
     "However, as more elements are enqueued to the set, the tail keeps pointing to the tail.\n",
     "\n",
-    "Enqueueing has $O(1)$ time complexity because the node is added always at the end of the queue.\n",
+    "Enqueueing has $O(1)$ time complexity because the node is always added at the end of the queue.\n",
     "\n",
     "### `queue.dequeue`\n",
     "![Dequeue](./assets/dequeue.png)\n",
     "\n",
-    "**Dequeue** is the deletion operation. The deletion occurs at the beginning of the queue. When the queue is empty the deletion is not performed. On the other hand, when the queue has elements the *head* reference goes to its current *next* and the *head* is returned to the caller. This has no impact on the *tail* reference.\n",
+    "**Dequeue** is the deletion operation. The deletion occurs at the beginning of the queue. When the queue is empty the deletion is not performed. On the other hand, when the queue has elements the *head* reference goes to its current *next*, and the *head* is returned to the caller. This has no impact on the *tail* reference.\n",
     "\n",
     "Dequeueing has $O(1)$ time complexity too because the *head* reference is moved to the next node."
    ]
@@ -294,7 +294,7 @@
    "metadata": {},
    "source": [
     "### `queue.peek`\n",
-    "The `peek` function looks at the head of the queue without popping it out from the queue. With this operation we always have a way to look at the head value. No matter how many elements keep being enqueued, this operation will always look to the *head*."
+    "The `peek` function looks at the head of the queue without popping it out from the queue. With this operation, we always have a way to look at the head value. No matter how many elements are enqueued, this operation will always look to the *head*."
    ]
   },
   {
@@ -363,7 +363,7 @@
    "metadata": {},
    "source": [
     "## Runtime Complexity Overview\n",
-    "| Operation | Runtime Complexixty |\n",
+    "| Operation | Runtime Complexity |\n",
     "|:---------:|:-------------------:|\n",
     "| Enqueue   | $O(1)$              |\n",
     "| Dequeue   | $O(1)$              |\n",