add preface to export, small fixes in other sections (#118)

Author: spring1843

.github/scripts/export-md.sh

@@ -8,6 +8,7 @@ source "${SCRIPT_DIR}/sections.sh"
 
 declare -a files=(
   README.md
+  preface.md
   complexity.md
 )
 files+=("${sections[@]/%//README.md}")

array/README.md

@@ -64,8 +64,8 @@ func main() {
 	nums = nums[:len(nums)-1] // drop last element
 	nums = nums[1:]           // drop first element
 	nums = nums[1:]           // all elements from index 1 to the end
-	nums = nums[:2]           // all elements from index 0 to 2
-	nums = nums[1:2]          // the element from index 1 to 2
+	nums = nums[:2]           // all elements from index 0 to 1
+	nums = nums[1:2]          // the element at index 1
 	fmt.Println(nums)         // Prints [4]
 }
 ```

complexity.md

@@ -117,7 +117,6 @@ The time complexity of O(n*Log n) is commonly observed when it is necessary to i
 * [Heap Sort](./heap/heap_sort.go)
 * [Knapsack](./greedy/knapsack.go)
 * [Find Anagrams](./hashtable/find_anagrams.go)
-* In order traversal of a [Binary Search Tree](./tree/README.md)
 
 ### Polynomial - O(n^2)
 

graph/README.md

@@ -88,11 +88,11 @@ When working with graphs, searching to solve problems is often necessary. The al
 * **Breadth First Search - BFS** used to find the shortest path
 * **Depth First Search - DFS** often a subroutine, in another algorithm. Used in maze traversal, cycle finding, and pathfinding
 
-Both BFS and DFS can be [implemented iteratively using a container (queue or stack)](./iterative_traversal_test.go).
+BFS can be implemented iteratively using a [queue](../queue/) and DFS can be implemented iteratively using a [stack](../stack/). This is demonstrated in the [iterative traversal](./iterative_traversal_test.go) rehearsal.
 
 #### Breadth First Search - BFS
 
-BFS is a non-recursive algorithm that employs a [queue](../queue) and is a generalization of [post-order traversal](../tree) in a tree. When provided with a graph G and a vertex V, BFS systematically explores all nodes in G that are reachable from V, as illustrated in the following example:
+BFS is a non-recursive algorithm that employs a [queue](../queue). When provided with a graph G and a vertex V, BFS systematically explores all nodes in G that are reachable from V, as illustrated in the following example:
 
 ```Go
 package main

greedy/README.md

@@ -8,8 +8,6 @@ Therefore, greed and greedy algorithms may not always produce optimal solutions
 
 ## Implementation
 
-The process for developing a greedy algorithm can be structured into six steps.
-
 The process for developing a greedy algorithm can be broken down into six steps:
 
 1. Identify the optimal problem structure.

hashtable/README.md

@@ -1,6 +1,6 @@
 # Hash Table
 
-Hash tables are a fundamental data structure that operates based on key-value pairs and enables constant-time operations for lookup, insertion, and deletion. Hash tables use immutable keys that can be strings or integers among other things. However, in more complex applications, a hashing function, and different collision resolution methods such as separate chaining, linear probing, quadratic probing, and double hashing, can be used to ensure efficient performance.
+Hash tables are a fundamental data structure that operates based on key-value pairs and enables constant-time operations for lookup, insertion, and deletion. Hash tables use immutable keys that can be strings or integers among other things. However, in more complex applications, a hashing function, and different collision resolution methods such as separate chaining, linear probing, quadratic probing, and double hashing, can be used.
 
 ## Implementation
 

preface.md

@@ -14,7 +14,7 @@ This collection became a valuable resource, and I sought to share its benefits w
 
 ## Choosing Go as the Language
 
-Go initially aimed to replace C and C++, an ambitious goal given that operating systems like Linux and Windows and programming languages like Java and Python are written in C and C++. Go has matured over the past decade into a robust and solid option, finding its niche particularly in systems engineering where reliability and performance are essential.
+Go initially aimed to be a successor for C++, an ambitious goal given that operating systems like Linux and Windows and programming languages like Java and Python are written in C and C++. Go has matured over the past decade into a robust and solid option, finding its niche particularly in systems engineering where reliability and performance are essential.
 
 Go is simple. This simplicity is evident in several aspects. The language features few [keywords](https://go.dev/ref/spec#Keywords) that programmers from any background would likely recognize. Its syntax is minimal, offering a single type of loop, and no brackets are needed for conditions in if or for statements. The Go standard library, written in Go and assembly language, is frequently used not only to understand the internals of Go but also to learn how to write idiomatic Go code. Go maintains backward compatibility for its standard API, and significant changes require approval from the three original authors, ensuring that the language does not become a "Frankenstein".
 

recursion/README.md

@@ -2,7 +2,7 @@
 
 Recursion is a computational technique that implements a [divide-and-conquer](../dnc) approach to problem-solving by breaking down a complex problem into smaller sub-problems. It consists of two components:
 
-* One or more base cases that provide output for simple inputs
+* One or more base cases that provide output for simple inputs and terminate recursion
 * A recursive case that combines the outputs obtained from recursive function calls to generate a solution for the original problem.
 
 Although recursions enhance code readability, they are usually inefficient and challenging to debug. Consequently, unless they provide a more efficient solution to a problem, such as in the case of [quicksort](../dnc/quick_sort_test.go), they are generally not preferred.

strings/README.md

@@ -13,7 +13,7 @@ In Go, strings are a data type. Behind the scenes strings are a slice of bytes.
 * [Title](https://golang.org/pkg/strings/#Title), [ToLower](https://golang.org/pkg/strings/#ToLower), [ToUpper](https://golang.org/pkg/strings/#ToUpper)
 * [Trim](https://golang.org/pkg/strings/#Trim), [TrimSpace](https://golang.org/pkg/strings/#TrimSpace), [TrimSuffix](https://golang.org/pkg/strings/#TrimSuffix), [TrimPrefix](https://golang.org/pkg/strings/#TrimPrefix)
 
-When a string is iterated in Go using the `range` keyword, every element becomes a [rune](https://blog.golang.org/strings#TOC_5.) which is the same as `int32`. If the code being written works with many single-character strings, it is better to define variables and function parameters as `rune`. The following code shows how to iterate through a string.
+When a string is iterated in Go using the `range` keyword, every element becomes a [rune](https://blog.golang.org/strings#TOC_5.) which is an alias for the type `int32`. If the code being written works with many single-character strings, it is better to define variables and function parameters as `rune`. The following code shows how to iterate through a string.
 
 ```Go
 package main

tree/README.md

@@ -10,8 +10,8 @@ Traversing a tree means exploring every node in a tree and performing some work
      4			Traversal Name		Order 		        Example
     / \
    /   \		In-Order                left,self,right		1,2,3,4,5,6,7
-  2     6		Pre-Order,DFS		self,left,right		4,2,1,3,6,5,7
- / \   / \		Post-Order,BFS		left,right,self		1,3,2,5,7,6,4
+  2     6		Pre-Order 		self,left,right		4,2,1,3,6,5,7
+ / \   / \		Post-Order		left,right,self		1,3,2,5,7,6,4
 1   3 5   7
 ```