Update basic_concepts.md

Author: djeada

notes/basic_concepts.md

@@ -10,78 +10,76 @@ Data structures and algorithms are fundamental concepts in computer science that
 
 A **data structure** organizes and stores data in a way that allows efficient access, modification, and processing. The choice of the appropriate data structure depends on the specific use case and can significantly impact the performance of an application. Here are some common data structures:
 
-1. An **array** is like a row of lockers, each numbered in order, where each locker can hold one item of the same type. Formally, an array is a contiguous block of memory that stores a fixed-size sequence of elements of the same type. Arrays are effective for quick access to data by index, but their size cannot change once set, making them less flexible for adding or removing elements.
-2. A **stack** is like a stack of plates. You add new plates on top (push), and take plates from the top (pop). This follows the "Last-In, First-Out" (LIFO) principle, meaning the last item added is the first one removed. Stacks are commonly used in programming for managing function calls (function call stack) and 'undo' operations in software applications.
-3. A **queue** is like a line at a checkout counter. People join at the back (enqueue) and leave from the front (dequeue). This follows the "First-In, First-Out" (FIFO) principle, where the first item added is the first one removed. Queues are useful for processing items in the order they arrive, such as task scheduling or event handling in computing systems.
-4. A **linked list** is like a treasure hunt where each clue (node) points to the next one. Each node contains a value and a reference (pointer) to the next node. This makes linked lists dynamic and efficient for inserting and removing elements at any position in the list.
-5. A **tree** is like a family tree, starting with one person (root) and branching out to children (nodes), with each node possibly having its own children. Formally, a tree is a hierarchical data structure composed of nodes arranged in multiple levels. Trees are useful for representing hierarchical relationships, such as filesystem structures or organizational charts.
-6. A **graph** is like a network of cities connected by roads. Each city is a node, and each road is an edge connecting two nodes. Edges can be one-way (directed) or two-way (undirected). Graphs are used to model complex relationships and connections between elements, such as social networks, web pages (links), and routes between locations.
+1. Imagine an **array** as a row of lockers, each labeled with a number and capable of holding one item of the same type. Technically, arrays are blocks of memory storing elements sequentially, allowing quick access using an index. However, arrays have a fixed size, which limits their flexibility when you need to add or remove items.
+2. Think of a **stack** like stacking plates: you always add new plates on top (push), and remove them from the top as well (pop). This structure follows the Last-In, First-Out (LIFO) approach, meaning the most recently added item is removed first. Stacks are particularly helpful in managing function calls (like in the call stack of a program) or enabling "undo" operations in applications.
+3. A **queue** is similar to a line at the grocery store checkout. People join at the end (enqueue) and leave from the front (dequeue), adhering to the First-In, First-Out (FIFO) principle. This ensures the first person (or item) that arrives is also the first to leave. Queues work great for handling tasks or events in the exact order they occur, like scheduling print jobs or processing messages.
+4. You can picture a **linked list** as a treasure hunt, where each clue leads you to the next one. Each clue, or node, holds data and a pointer directing you to the next node. Because nodes can be added or removed without shifting other elements around, linked lists offer dynamic and flexible management of data at any position.
+5. A **tree** resembles a family tree, starting from one ancestor (the root) and branching out into multiple descendants (nodes), each of which can have their own children. Formally, trees are hierarchical structures organized across various levels. They’re excellent for showing hierarchical relationships, such as organizing files on your computer or visualizing company structures.
+6. Consider a **graph** like a network of cities connected by roads. Each city represents a node, and the roads connecting them are edges, which can either be one-way (directed) or two-way (undirected). Graphs effectively illustrate complex relationships and networks, such as social media connections, website link structures, or even mapping transportation routes.
 
 ![ds](https://user-images.githubusercontent.com/37275728/185381435-9335db5b-8c9a-4e74-87dc-deac3c0356f1.png)
 
 ### Algorithms
 
-Algorithms are step-by-step instructions to solve specific problems or perform tasks. They are everywhere in fields like computer science, mathematics, and engineering. To evaluate how good an algorithm is, we often look at its efficiency in terms of time complexity (how long it takes to run) and space complexity (how much memory it uses).
+An **algorithm** is like a clear and detailed set of instructions or steps for solving a specific problem or performing a particular task. Think of it like following a precise recipe when cooking:
 
-Think of an algorithm like a recipe for cooking. It consists of a series of steps to follow to achieve a specific result. Here are the key characteristics of a good algorithm:
+- The ingredients needed represent the **input**, which are the data or information the algorithm uses to begin its work.
+- The finished dish is the **output**, or the final result the algorithm provides after processing the input.
+- Each instruction in an algorithm must be clear and precise. This clarity is known as **definiteness**, ensuring anyone following the steps reaches the same result without confusion.
+- Algorithms must have a definite end-point, known as **termination**, meaning they can’t run indefinitely and must eventually finish with a result.
+- Every step in an algorithm must be practical and achievable, known as **effectiveness**, ensuring the instructions can realistically be carried out to achieve the desired outcome.
 
-- The data that an algorithm works with is referred to as its **input**, much like the ingredients required to prepare a dish in a recipe.
-- Just as a recipe leads to a completed dish, the algorithm produces an **output**, which represents the final result after processing the input.
-- It is essential that every step of the algorithm is defined with clarity and precision, ensuring that there is no ambiguity in the process, a concept known as **definiteness**.
-- Similar to how a recipe has a defined end point when the dish is ready, an algorithm must have **finiteness**, meaning it will stop after a specific number of steps.
-- For an algorithm to be **effective**, each step should be simple, executable, and directly contribute toward reaching the final result, just as every action in a recipe is purposeful and achievable.
+To evaluate how good an algorithm is, we often look at its efficiency in terms of time complexity (how long it takes to run) and space complexity (how much memory it uses). We will discuss it in greater detail in later sections.
 
 #### Algorithms vs. Programs
 
-Understanding the difference between an algorithm and a program helps clarify their roles in problem-solving:
+An **algorithm** is a high-level blueprint for solving a specific problem. It is abstract, language-independent, and specifies a clear sequence of steps without relying on any particular programming syntax. An algorithm can be thought of as a recipe or method for solving a problem and can be represented in multiple forms, such as plain text or a flowchart.
 
-An algorithm is like a high-level blueprint for solving a specific problem. It is abstract and language-independent, detailing a sequence of steps without any specific syntax. You can think of an algorithm as a recipe that outlines a method for solving a problem, and it can be represented in various ways, such as in plain text or as a flowchart.
-
-For example, consider an algorithm for adding two numbers:
+**Example:** Algorithm for adding two numbers:
 
 ```
 Step 1: Start
 Step 2: Declare variables num1, num2, and sum.
 Step 3: Read values into num1 and num2.
-Step 4: Add num1 and num2 and store the result in sum.
-Step 5: Print sum
-Step 6: Stop
+Step 4: Add num1 and num2; store the result in sum.
+Step 5: Print sum.
+Step 6: Stop.
 ```
 
-This algorithm can also be shown as a flowchart:
+This algorithm can also be visualized using a flowchart:
 
 ```
 ---------------------
-|  Start            |
+|       Start       |
 ---------------------
-        |
-        V
------------------------------
-|  Declare num1, num2, sum  |
------------------------------
-        |
-        V
-------------------------
-|  Read num1 and num2  |
-------------------------
-        |
-        V
------------------------
-|  sum = num1 + num2  |
------------------------
-        |
-        V
-----------------------
-|  Print sum         |
-----------------------
-        |
-        V
-----------------------
-|  Stop              |
-----------------------
+         |
+         V
+------------------------------
+| Declare num1, num2, sum    |
+------------------------------
+         |
+         V
+--------------------------
+| Read num1 and num2     |
+--------------------------
+         |
+         V
+--------------------------
+| sum = num1 + num2      |
+--------------------------
+         |
+         V
+--------------------------
+| Print sum              |
+--------------------------
+         |
+         V
+--------------------------
+| Stop                   |
+--------------------------
 ```
 
-On the other hand, a program is a concrete, language-dependent implementation of an algorithm. It follows the syntax rules of a particular programming language. For instance, the above algorithm can be implemented in Python as:
+In contrast, a **program** is a concrete implementation of an algorithm. It is language-dependent and adheres to the specific syntax and rules of a programming language. For example, the above algorithm can be implemented in Python as:
 
 ```python
 num1 = int(input("Enter first number: "))
@@ -90,7 +88,10 @@ sum = num1 + num2
 print("The sum is", sum)
 ```
 
-Algorithms are abstract steps that always terminate after a finite number of steps. In contrast, some programs can run indefinitely until an external action stops them. For example, an operating system is a program designed to run continuously in a loop until the computer is turned off.
+To recap:
+
+- Algorithms are abstract instructions designed to terminate after a finite number of steps.
+- Programs are concrete implementations, which may sometimes run indefinitely or until an external action stops them. For instance, an operating system is a program designed to run continuously until explicitly terminated.
 
 #### Types of Algorithms
 
@@ -189,11 +190,11 @@ Pattern matched starting at index 10 in the text.
 
 Algorithmic complexity helps us understand the computational resources (time or space) an algorithm needs as the input size increases. Here’s a breakdown of different types of complexity:
 
-* **Best case complexity** is the minimum time or space an algorithm requires for a given input size. For instance, an algorithm with a best case time complexity of O(1) always runs in constant time, regardless of the input size.
-* **Average case complexity** signifies the average time or space an algorithm needs for all possible inputs of a given size. Calculating this can be more challenging because it requires understanding the distribution of possible inputs and their effect on the algorithm's performance.
-* **Worst case complexity** indicates the maximum time or space an algorithm may take for any input of a certain size. This type of complexity is often the most critical since it provides an upper bound on the algorithm's execution time, offering predictability.
-* **Space complexity** represents the total amount of memory an algorithm needs relative to the input size. This becomes important when memory resources are limited and the algorithm's efficiency is necessary.
-* **Time complexity** measures the computational time an algorithm takes as the input size grows. This is the most frequently analyzed type of complexity because the speed of an algorithm often determines its usability.
+* *Best-case complexity* describes how quickly or efficiently an algorithm runs under the most favorable conditions. For example, an algorithm with a best-case complexity of O(1) performs its task instantly, regardless of how much data it processes.
+* *Average-case complexity* reflects the typical performance of an algorithm across all possible inputs. Determining this can be complex, as it involves analyzing how often different inputs occur and how each one influences the algorithm's overall performance.
+* *Worst-case complexity* defines the maximum amount of time or resources an algorithm could consume when faced with the most difficult or demanding inputs. Understanding the worst-case scenario is crucial because it sets an upper limit on performance, ensuring predictable and reliable behavior.
+* *Space complexity* refers to how much memory an algorithm needs relative to the amount of data it processes. It's an important consideration when memory availability is limited or when optimizing an algorithm to be resource-efficient.
+* *Time complexity* indicates how the execution time of an algorithm increases as the input size grows. Typically, this is the primary focus when evaluating algorithm efficiency because faster algorithms are generally more practical and user-friendly.
 
 #### Analyzing Algorithm Growth Rates