## An Illustrative Introduction to Algorithms

This book is designed for undergraduate upper-class students and programmers that want to expand their horizon. It can be used as a supplementary book alongside the complex book. Although no code is present, the reader will learn how the algorithm works to the point where they can solve it themselves. Readers will gain the knowledge necessary to solve those mathematically intensive algorithmic problems that were presented in the complex book.

Each chapter consists of a brief description of how the algorithm works followed by a detailed example or two. No steps are skipped during the traversal process. The reader is presented with a clear, simplified approach to solving the algorithm that the chapter is dedicated to. Each chapter follows a natural progression from the previous chapter.

Welcome to my series on computer science algorithms, where we explore the most pivotal and commonly used algorithms in the field. This series is designed for anyone with an interest in computer science, from students just beginning their journey, to professionals seeking to enhance their algorithmic skills, and even enthusiasts intrigued by the art of problem-solving. Here, you’ll find a rich exploration of various algorithms, ranging from fundamental sorting and searching techniques to more advanced topics like graph theory and dynamic programming. Join me in this exciting exploration, and together, let’s build a strong, comprehensive understanding of the algorithms that form the backbone of computer science.

Let me make an educated guess: you learn best when the information is presented to you visually. Me too. This series is going to attempt to teach you a rather complex subject without the use of any words. Okay, maybe some words. Most illustrations will have an explanation attached to them. There are three approaches to reading this series:

- Read about the algorithm online and then see if you can follow the traversal illustrated in each article.
- View the algorithm in action by going through the article designated for the algorithm and then go online and read further about it.
- Just view the algorithm as is outlined in this series. A significant amount of time was dedicated to make these algorithms easy to follow.

Not everything here is on algorithm traversal, however, everything is related to algorithms. We’ll touch on Big O complexity for some of the algorithms we discuss in this book. We’ll do so by showing the best (Ω), average (Θ) and worst (O) time complexity. You may have encountered Big O notation, but a good portion of people have not encountered Big Omega (Ω) or Big Theta (Θ) notation.

A few other sections are dedicated to data structures that you may need to know before proceeding to the specific algorithm that utilizes those data structures. The series is intended for first time learners as well as a reference guide for all programmers. The series does not contain any code since it’s readily available online. The goal of this series is to get you acquainted with the concept of each algorithm. If you can visualize it, you can code it.

This series is here if you don’t want to purchase the book. The book is simply to support me to continue writing tutorials like these for everyone.

The concept of algorithms dates back to ancient times, with the term ‘algorithm’ itself derived from the name of the Persian mathematician, Al-Khwarizmi, who lived in the 9th century. His seminal work, “Al-Kitab al-Mukhtasar fi Hisab al-Jabr wal-Muqabala” (The Compendious Book on Calculation by Completion and Balancing), introduced systematic and logical methods for solving linear and quadratic equations, which are considered the basis for modern algorithms.

#### Read More

## Big O Complexity

Big O complexity, often referred to as Big O notation, is a mathematical concept used in computer science to describe the performance or complexity of an algorithm. Specifically, it characterizes the time complexity (how the running time of an algorithm increases with the size of the input) and space complexity (how the amount of memory or storage space required by an algorithm increases with the size of the input) in the worst-case scenario. Here are some key points about Big O complexity:

- Asymptotic Analysis: Big O notation provides an asymptotic analysis of an algorithm, meaning it describes the behavior of the algorithm as the input size approaches infinity. It’s a way of generalizing the performance of an algorithm to understand how it will scale with larger inputs.
- Worst-Case Scenario: It typically focuses on the worst-case scenario, giving an upper limit on the time or space requirements of an algorithm. This helps in understanding the maximum resources that an algorithm might require.
- Simplification of Complexity: Big O notation simplifies the complexity of an algorithm by ignoring constants and less significant terms. For example, an algorithm with a complexity of
`3n² + 2n + 1`

is represented as O(n²), focusing on the term that will have the most significant impact as the size of the input grows - Comparison and Analysis of Algorithms: Big O notation is crucial for comparing the efficiency of different algorithms, particularly when choosing the most suitable algorithm for a specific problem or when optimizing existing algorithms for better performance.

The Big O is generally used to describe the worst-case scenario, while Big Omega describes the best-case scenario, and Big Theta gives a tight bound (average-case scenario). The complexities for some algorithms can vary based on the implementation details or the structure of the input data. For example, Prim’s algorithm has a worst-case complexity of O(V²) when implemented with an adjacency matrix, but it can be reduced to O(E log V) when using a binary heap and adjacency list. Similarly, Quick Sort has a worst-case complexity of O(n²), but with good pivot selection techniques, the average case is often considered as Θ(n log n).

Understanding Big O complexity is fundamental in algorithm design and analysis, as it helps in predicting how an algorithm will perform as the size of the input data increases, thus influencing decisions in software development and system design.

The graph is self-explanatory. Try to stick away from the algorithms that have a time complexity in red and attempt to stay with the ones in orange if you have no other choice. Yellow and green is where you would like to optimally reside. With some extra research, you’ll soon see that even O( *n log(n) *) is good enough.

Common Big O Classes: Some common Big O complexity classes include:

- O(1): Constant time complexity, indicating that the algorithm’s performance is independent of the size of the input data.
- O(log n): Logarithmic time complexity, where the performance grows logarithmically with the input size.
- O(n): Linear time complexity, where performance scales linearly with the input size.
- O(n log n): Log-linear time complexity, common in algorithms that combine linear and logarithmic behaviors.
- O(n²): Quadratic time complexity, often seen in algorithms with nested loops over the input data.

In 1998, Larry Page and Sergey Brin, the founders of Google, developed the PageRank algorithm, which significantly transformed the way information is retrieved on the Internet. This algorithm ranked web pages based on their links from other pages, effectively measuring the importance of a webpage by the number of links directed to it. The introduction of PageRank was pivotal in improving the relevance and quality of search results, contributing to Google’s rise as the world’s most popular search engine.

#### Read More

Algorithm | Best Ω | Average Θ | Big O (Worst) |
---|---|---|---|

Binary Tree Search In-Pre-Post- Order | Ω(n) | Θ(n) | O(n) |

Binary Search | Ω(1) | Θ(log n) | O(log n) |

Bubble Sort | Ω(n) | Θ(n²) | O(n²) |

Breadth-First Search (BFS) | Ω(|V| + |E|) | Θ(|V| + |E|) | O(|V| + |E|) |

Depth First Search (DFS) – Directed Graph | Ω(|V| + |E|) | Θ(|V| + |E|) | O(|V| + |E|) |

Depth First Search (DFS) – Undirected Graph | Ω(|V| + |E|) | Θ(|V| + |E|) | O(|V| + |E|) |

Heap Sort | Ω(n log n) | Θ(n log n) | O(n log n) |

Insertion Sort | Ω(n) | Θ(n²) | O(n²) |

Kruskal’s Algorithm | Ω(E log E) | Θ(E log E) | O(E log E) |

Merge Sort | Ω(n log n) | Θ(n log n) | O(n log n) |

Prim’s Algorithm | Ω(V log V) | Θ(E log V) | O(V²) |

Quick Sort | Ω(n log n) | Θ(n log n) | O(n²) |

Selection Sort | Ω(n²) | Θ(n²) | O(n²) |

## What Are Sorting Algorithms?

Sorting algorithms are fundamental procedures in computer science used to arrange elements in a list or array into a specified order. The most common orders are numerical or lexicographical, depending on the type of data being sorted. These algorithms are crucial because sorting data efficiently can drastically improve the performance of a system, especially when dealing with large volumes of data. Sorting makes it easier to search, analyze, and display data effectively. In the realm of algorithms, sorting techniques are often some of the first to be taught, as they encapsulate key concepts in computer science like problem-solving, efficiency, and algorithmic design.

The design and analysis of sorting algorithms provide valuable insights into the efficiency of different algorithmic strategies. Each sorting algorithm has a specific set of instructions or logic to follow, which can vary greatly in complexity and efficiency. Some algorithms, like Bubble Sort, are simple and intuitive, making them an excellent educational tool for beginners, but they may not be efficient for large datasets. On the other hand, more complex algorithms like Quick Sort and Merge Sort offer better efficiency and are widely used in real-world applications. Understanding these algorithms involves grasping concepts such as recursion, divide and conquer strategies, and the trade-offs between time and space complexity.

Moreover, the study of sorting algorithms extends beyond their immediate practical application. It lays the foundation for understanding more complex data structures and algorithms. For instance, many algorithms are based on the principle of sorting elements before performing more complex operations, such as searching or indexing. Furthermore, the principles learned in sorting algorithms, such as the importance of algorithmic efficiency and the impact of different data structures on algorithm performance, are applicable to a wide range of problems in computer science. Therefore, learning about sorting algorithms is not just about sorting itself, but about developing a deeper understanding of how to approach and solve computational problems efficiently.

### Bubble Sort

The Bubble Sort algorithm sorts an array of items in increasing order. It steps through the array and compares the adjacent elements. Let’s look at it visually.

### Insertion Sort

Explore Insertion Sort: Learn this simple yet powerful sorting algorithm, perfect for small datasets and a fundamental building block in computer science.

### Merge Sort

Unlock the power of Merge Sort, a highly efficient and stable sorting algorithm ideal for managing large datasets with optimal performance

### Quick Sort

Dive into Quick Sort: Uncover this fast, efficient sorting algorithm essential for handling large datasets and optimizing computational performance.

### Heap Data Structure

Master the technique of creating a Heap from an array – a fundamental skill for efficient data sorting and priority queue management.

Constructing Min-Heap From a Tree

Master constructing a Min-Heap from a tree: Streamline your approach to data organization for improved algorithm efficiency and speed.

Constructing Min-Heap From an Array

Learn to construct a Min-Heap from an array: Essential for efficient data management and optimizing sorting algorithms in computing.

Constructing Max-Heap From a Tree

Transform a tree into a Max-Heap: Master this crucial technique for efficient data sorting and optimized priority queue management.

Constructing Max-Heap From an Array

Discover how to construct a Max-Heap from an array: a key step in data organization for optimizing sorting and selection algorithms.

Deleting the Root Node From Min-Heap

Learn the art of deleting the root from a Min-Heap. Essential for maintaining heap structure and optimizing data retrieval in complex algorithms.

#### Top 20 Real-World Algorithm Uses

- Cybersecurity
- Autonomous Vehicles
- Search Engine Optimization
- Online Advertising
- Social Media Feeds
- E-commerce Recommendations
- Traffic Routing
- Financial Market Analysis
- Credit Scoring
- Fraud Detection
- Medical Diagnosis
- Drug Discovery
- Weather Forecasting
- Image and Voice Recognition
- Language Translation Services
- Supply Chain Optimization
- Energy Consumption Optimization
- Agricultural Planning
- Content Filtering
- Educational Technology

## Real-World Algorithm Applications

#### As if you needed convincing to learn algorithms

Computer science algorithms have become deeply integrated into various aspects of modern life, driving innovation and efficiency across multiple industries. In the digital realm, algorithms like PageRank revolutionize how search engines rank web pages, while social media platforms utilize sophisticated algorithms to curate personalized content feeds. E-commerce sites leverage recommendation algorithms to enhance shopping experiences, suggesting products based on consumer behavior. In finance, algorithms play a crucial role in stock market analysis, credit scoring, and fraud detection, using pattern recognition and predictive analytics. The healthcare sector also benefits from algorithms, particularly in medical diagnostics and drug discovery, where they assist in analyzing patient data and simulating molecular structures.

Furthermore, these algorithms are instrumental in the advancement of cutting-edge technologies such as autonomous vehicles, where they process sensor data for navigation and decision-making. They also power language translation services, enabling real-time cross-linguistic communication. In cybersecurity, algorithms are the frontline defense against cyber threats. The growing field of smart grids in energy management and agricultural planning algorithms showcase the role of algorithms in optimizing natural resource use. Finally, in education, adaptive learning algorithms are tailoring educational content to individual needs, revolutionizing the learning experience. These diverse applications underscore the transformative impact of computer science algorithms in streamlining operations, enhancing user experiences, and solving complex real-world problems across sectors.

### Selection Sort

The Selection Sort algorithm sorts an array by looking for the smallest item and moving it to the front of the list. That’s really all you have to know.

## Why Learn Data Structures?

Learning data structures is an essential step in mastering algorithms, forming the cornerstone of efficient algorithmic solutions. Data structures, such as arrays, linked lists, trees, and graphs, provide the framework for organizing data in a way that is both efficient and accessible for various computational tasks. Understanding data structures is key to developing algorithms that are not only functional but also optimized for performance, whether it’s for sorting data quickly, managing large datasets effectively, or solving complex problems like network connectivity or pathfinding. In essence, a solid grasp of data structures empowers you to write algorithms that are not just code, but elegant solutions finely tuned to the specific needs of your computational challenges.

### Adjacency Matrix

The adjacency matrix is a square matrix that’s used to represent a graph. The elements that are next to each other represent adjacent vertices.

### Adjacency List

The adjacency list is another way to represent adjacent vertices. Why would you want to create an adjacency list? Again, to save time.

Algorithms are the backbone of machine learning models, enabling computers to learn from and make decisions based on data. A well-known example is the use of neural networks, a type of machine learning algorithm inspired by the human brain. These networks consist of layers of interconnected nodes that can learn to recognize patterns and make decisions by analyzing vast amounts of data. This capability is at the heart of many modern AI applications, from voice recognition systems like Amazon’s Alexa and Apple’s Siri to sophisticated image recognition software used in autonomous vehicles.

#### Read More

## What Are Graph Traversal Algorithms?

Graph traversal algorithms are a class of algorithms in computer science designed to visit, check, or update each node in a graph data structure. A graph is a collection of nodes (or vertices) connected by edges, and traversing these graphs means systematically following these edges to visit the nodes in a specific order. Graph traversal is a fundamental operation in the field of computer science, used in a wide array of applications ranging from network analysis and geographical mapping to database theory and artificial intelligence. These algorithms are particularly important in scenarios where the relationship or connection between elements is as crucial as the elements themselves.

The primary purpose of graph traversal algorithms is to explore the nodes of a graph, ensuring that each node is visited or processed according to the algorithm’s rules. The traversal can serve various objectives, such as searching for a specific node, analyzing the structure of the graph, or computing the shortest path between nodes. In doing so, these algorithms help in solving complex computational problems by breaking them down into more manageable sub-problems. The choice of a particular graph traversal algorithm depends on the specific characteristics of the graph and the nature of the problem to be solved. Regardless of the specific algorithm used, graph traversal remains a cornerstone technique in computer science, demonstrating fundamental concepts of algorithm design, data organization, and problem-solving strategies.

### Depth First Search (DFS)

The Depth First Search algorithm traverses the graph and explores each adjacent node before backtracking and moving to the next node utilizing the stack.

### Topological Sorting

Topological sorting is the result you get when you sort the tree in order of decreasing finishing times. Run DFS to get discovery times and finishing times

### Breadth First Search (BFS)

The Breadth First Search algorithm is like the Depth First Search algorithm with the exception that it uses a queue rather than a stack.

## Greedy Algorithms

The Greedy Method is an approach for solving certain types of optimization problems. The greedy algorithm chooses the optimum result at each stage.

## Minimum Spanning Tree (MST) Algorithms

Minimum Spanning Tree (MST) algorithms are a crucial category in graph theory and computer science, used for finding the most efficient way to connect all nodes (or vertices) in a weighted graph. These algorithms are particularly relevant in scenarios where the graph represents a network, like computer networks, transportation grids, or utility supply lines, and the goal is to minimize the total connection cost. In such a graph, each edge carries a weight, representing the cost, distance, or any metric that quantifies the effort or resources needed to establish that connection. An MST algorithm seeks to connect all the nodes with the least total weight, ensuring that no cycles (closed loops) are formed and that all nodes are reachable from each other.

The importance of MST algorithms stems from their ability to optimize resources and costs in network design and construction. For example, in laying out telecommunications networks, MST algorithms can determine the optimal paths for cables to connect various cities, minimizing the total length of the cable. Similarly, in electrical grid layouts, these algorithms help in planning the wiring to connect various substations or consumers with the least amount of wire. The resulting tree, or network, is “spanning” because it covers all vertices and “minimum” because the total weight of its edges is as low as possible compared to any other spanning tree of the graph. MST algorithms are not only fundamental in theoretical computer science and discrete mathematics but are also widely applied in practical problem-solving across various engineering and planning domains.

### Minimum Spanning Trees

The Minimum Spanning Tree connects all vertices utilizing the minimum path. This is just a quick intro since we will cover MSTs in detail later.

### Kruskal’s Algorithm

Kruskal’s algorithm generates a minimum spanning tree. Kruskal’s Algorithm keeps selecting the least costly edge until a minimum spanning tree is created.

### Prim’s Algorithm

Prim’s Algorithm is similar to Kruskal’s Algorithm. It’s a greedy algorithm that finds the MST (minimum spanning tree) for a weighted, undirected graph

### Binary Tree Traversal – Depth First

Let’s look at the In-Order Binary Tree Traversal. Starting from the root node, we’ll visit all the nodes in the left subtree and then the right subtree.

In High-Frequency Trading (HFT), algorithms are used to execute a large number of orders at extremely high speeds, often in fractions of a second. These algorithms analyze market conditions to make quick decisions about buying or selling stocks, options, futures, and other financial instruments. They can detect trends and patterns in market data that are imperceptible to human traders, allowing them to capitalize on small price fluctuations.

#### Read More

## Why Study Computer Science Algorithms?

In today’s technology-driven world, the importance of understanding and mastering algorithms cannot be overstated. Algorithms are more than just a series of coded steps or procedures; they are the bedrock of computational problem-solving and the driving force behind modern software development and data analysis. Learning algorithms equips individuals with essential skills that are critical not only in the realm of computer science but also in various aspects of professional and everyday life. Whether you are a seasoned programmer, a student stepping into the world of computing, or a professional looking to enhance your analytical skills, the knowledge of algorithms opens a gateway to improved problem-solving capabilities, better programming proficiency, lucrative career opportunities, a deeper understanding of computer science, and the ability to efficiently process and interpret vast amounts of data. This foundational skill set is indispensable in navigating and excelling in the fast-paced and ever-evolving technological landscape.

**01**

### Problem-Solving Skills

Algorithms are at the heart of problem-solving in computing. Learning algorithms teaches you how to dissect complex problems and devise efficient solutions. This skill is not only applicable in programming but also in everyday life where logical thinking and problem-solving are essential.

**02**

### Enhanced Programming Abilities

A deep understanding of algorithms directly translates to improved programming skills. Knowing various algorithms and their applications allows you to write more efficient, effective, and optimized code. This is crucial in a wide range of tasks, from simple data processing to complex system design.

**03**

### Career Opportunities

Proficiency in algorithms is highly valued in the tech industry. Many tech companies, especially those that focus on software development, data science, and artificial intelligence, prioritize candidates who have a strong grasp of algorithms during their hiring process. This knowledge can open doors to prestigious and lucrative career paths.

**04**

### Better Understanding of Computer Science

Algorithms form the foundation of computer science. Learning them helps you understand how software and data structures work at a fundamental level. This understanding is critical for diving deeper into more advanced computer science topics like machine learning, data mining, and artificial intelligence.

**05**

### Efficiency in Handling Data

In today’s data-driven world, algorithms play a key role in data analysis and manipulation. Knowledge of algorithms enables you to handle, process, and analyze large datasets more efficiently, making it possible to derive meaningful insights from data that can inform decision-making and strategy in business and research.

### Binary Trees

Binary Tree – Inserting a Node

When inserting a node, remember this rule: nodes will only be added as leaves in the tree. Let’s see how to insert a node into a binary tree.

Binary Tree – Deleting a Leaf in a Tree

When deleting a leaf in the tree, the structure of the tree does not change. Let’s look at this simple example of deleting a leaf algorithmically.

Binary Tree – Deleting a Node with One Child

Exactly what it sounds like. We’ll be deleting a node from a tree that has only one child. Let’s look at our tree and examine which nodes have one child.

Binary Tree – Deleting a Node with Two Children

What would happen if we wanted to remove a node from a tree? We’ll take a look at how to remove a node with two children. Yes, it’s part of algorithms.

## What is Dynamic Programming in Algorithms?

Dynamic programming is a method used in algorithms to solve complex problems by breaking them down into simpler subproblems. It is particularly useful for optimization problems, where you seek to find the best solution among many possibilities. The core principle behind dynamic programming is the concept of overlapping subproblems and optimal substructure, which it exploits to improve efficiency and effectiveness in problem-solving.

- Overlapping Subproblems: This means that the problem can be broken down into smaller, reusable subproblems that are solved independently. In many complex problems, these subproblems recur several times, so solving each of them separately and then reusing these solutions (typically by storing them) avoids redundant computation. This is in contrast to other techniques like divide-and-conquer, where subproblems are generally non-overlapping.
- Optimal Substructure: This property means that the optimal solution to the problem can be constructed efficiently from the optimal solutions of its subproblems. In other words, the best solution to the overall problem depends on the best solutions to its subparts.

Dynamic programming algorithms typically follow two main approaches:

- Top-Down Approach (Memoization): This approach involves writing the procedure recursively in a natural manner but storing the results of the subproblems (usually in an array or hash table) to avoid computing the same results more than once.
- Bottom-Up Approach (Tabulation): This method starts by solving the smallest subproblems first and using their solutions to build up solutions to larger subproblems. This often involves filling up an array, where each cell represents a subproblem.

Dynamic programming is widely used in various fields of computer science, especially in areas requiring the solution of complex optimization problems. It’s essential in algorithms for operations ranging from shortest path finding in graphs (like the Floyd-Warshall algorithm) to sequence alignment in bioinformatics and many others. Understanding dynamic programming is key to developing efficient algorithms that solve problems which would otherwise be intractable due to their computational complexity.

### Planar Graphs

A planar graph is a graph that can be drawn on the plane with no intersecting arcs. The edges can intersect only at endpoints.

### Dynamic Programming

Another type of problem that arises in computer science is finding the longest common subsequence such as in BEADCA and ABCDA?

### All-Pairs Shortest Paths Matrix Multiplication

You’re presented with a graph and your goal is to find all-pairs of shortest paths using dynamic programming.

### Floyd-Warshall: All-Pairs Shortest Paths

The goal of the Floyd-Warshall algorithm is to find the shortest paths in a tree using Dynamic Programming.

## Dijkstra’s Algorithm

Dijkstra’s algorithm is a widely-used method in graph theory for finding the shortest path from a single source vertex to all other vertices in a weighted graph. It efficiently solves the single-source shortest path problem for graphs with non-negative edge weights, ensuring optimal pathfinding in diverse applications like network routing and geographical mapping.

## What are Graph Algorithms?

Graph algorithms are a set of instructions or rules designed to solve problems related to graph theory, where a graph is a data structure made up of nodes (or vertices) connected by edges (or links). These algorithms are pivotal in computing as they offer solutions for various complex problems involving networks, such as social network analysis, internet network routing, and schedule optimization. Graphs are versatile structures that can represent an incredibly wide range of problems in various fields including computer science, mathematics, engineering, biology, and social sciences. Graph algorithms are thus developed to explore these graphs, whether it’s to find the shortest path between two nodes, determine the most efficient route for a delivery, identify clusters of friends in a social network, or even map the structure of the internet.

One of the primary purposes of graph algorithms is to traverse or explore the graph. This can be in the form of visiting every node in the graph, a process known as graph traversal, which is foundational in many graph algorithms. Graph traversal methods, like Depth-First Search (DFS) and Breadth-First Search (BFS), are used for tasks ranging from searching for specific data in a network to algorithmic processes in machine learning and AI. Another significant aspect of graph algorithms involves finding the shortest path between nodes, which is crucial in network routing and GPS navigation. Algorithms like Dijkstra’s and Bellman-Ford are specifically designed for such tasks and are widely used in real-world applications.

### Bellman-Ford

The Bellman-Ford algorithm finds the shortest path to each vertex in the directed graph from the source vertex. Bellman-Ford can have negative edges.

### Jonson’s Algorithm

Johnson’s algorithm finds the shortest paths between all pairs of vertices in a directed graph. It converts negative edge weights into non-negative edge links.

### Clockwise and Counterclockwise Line Segment Intersection

If you’re given a problem to find out whether two line-segments intersect, there is an easy approach to this. Find the orientation of the line segments.

### Graham’s Scan

Graham’s Scan algorithm is a method used in computational geometry to compute the convex hull of a finite set of points in the plane. It operates by identifying a set of points that enclose all other points, forming the smallest convex polygon, and does so efficiently with a time complexity of O(n log n).

## What Else Should I Know

As we approach the conclusion of our algorithms series, there are some additional key concepts and advanced algorithms that deserve your attention to round out your knowledge. Understanding the lower bounds of algorithms is crucial; it refers to the theoretical minimum limit on the algorithm’s complexity, ensuring that you’re aware of the most efficient possible outcome for any given problem. This concept is vital because it sets a benchmark for algorithm performance, helping you evaluate how close your solution is to the optimal one.

Another significant concept is the Master Theorem, a cornerstone in analyzing the time complexity of algorithms that divide problems into smaller subproblems, solve these subproblems recursively, and then combine their solutions. The Master Theorem provides a direct way to get the running time of these divide-and-conquer algorithms without going through complex derivations each time.

## Lower Bounds

What are the lower bounds of an algorithm? Instead of giving you a formal definition, let’s look at weather. Most weather forecasters will provide you with the high and the low; the accurate temperature is somewhere in the middle. The high is your upper bound and the low is your lower bound. When relating this concept to algorithms, certain problems have provable lower bounds meaning that you will be incapable of providing a better answer than what was previously proven. For example, the minimum number of comparisons that you would need to sort 5 numbers is 7. Let’s look at a few examples.

### Example 1

You have 81 bottles of water. A bottle of water can be heavier than the others, lighter than the others, or equal in weight as the rest. What is the lower bound?

The formula to find the lower bounds of a problem is ceiling(logbn), where *b* is the number of possible outcomes and *n* is the number of possible answers. Most times *b* is going to be either 2 or 3. In the example above, you have 3 possibilities: heavier, lighter or equal. In most cases, the second variable, *n*, is more difficult to compute. In this example it’s straight forward: you have 81 bottles of water, so you have 81 possible answers. We’ll look at another example where it’s not so straight forward later.

ceiling(log₃81) = 4

### Example 2

You flip a coin 64 times. What is the lower bound?

In this example, **b **would equal 2 since during each flip we get either heads or tails. The number of possible answers, n, is 128. Why 128? We flip the coin 64 times and during each flip we can get either heads or tails, so the possible number of answers is 128.

ceiling(log₂128) = 7

### Example 3

Find the minimum number of comparisons required to sort 5 numbers.

The difficulty increases here but it’s still not bad. Once you see this type of problem, you apply the same logic. There is a total of 5! or 120 possible outcomes. A binary sort tree will have 7 levels for the sorting procedure.

ceiling(log₂n!)

ceiling(log₂5!)

ceiling(log₂120) = 7

## Master Theorem

There are many times when you have to write a recurrence relation for a divide and conquer problem. The example below shows the recurrence relation for a binary search algorithm where you divide the problem by half, and you accomplish a constant amount of work at each level:

*T(n) = T(n/2) + O(1)*

The general formula for the master theorem states that *T(n) = aT(n/b) + O(nᶜ**)* with *T(0) = 0* and *T(1) = Ө(1)*. There are three conditions to the master theorem:

- If c < log
_{b}(a), then T(n) = Θ(n^{logb(a)}) - If c = log
_{b}(a), then T(n) = Θ(n^{c}log(n)) - If c > log
_{b}(a), then T(n) = Θ(n^{c})

### Example 1

T(n) = T(7n/10) + n

log_{10/7}1 < n, therefore T(n) = Θ(n)

### Example 2

T(n) = 4T(n/3) + nlogn

log_{3}4 = 1.26185950… Since n grows faster than log(n), we get e(n^{log34})

### Example 3

T(n) = 16T(n/2) + 9999n^{2}

Let’s look at this problem in more detail

a = 16

b = 2

f(n) = 9999n^{2}

f(n) = O(n^{c}), where c = 2

log_{b}a = log_{2}16 = 4

4 > c

Therefore, T(n) = Θ(n^{logba}) = Θ(n^{4})

### Example 4

Sometimes the Master Theorem doesn’t work. We may just have to solve it recursively. Let’s look at this example.

T(n) = T(n-2) + n^{2}

= Ө(1) + … + (n-4)^{2} + (n-2)^{2} + n^{2}

= Ө(1) + 1^{2} + 2^{2} + 3^{2} + … + n^{2}

We should know that 1^{2} + 2^{2} + 3^{2} + … = n

= Ө(n • n^{2})

= Ө(n^{3})

Machine learning algorithms are increasingly used to analyze medical images like X-rays, MRIs, and CT scans, assisting doctors in detecting diseases more quickly and accurately. These algorithms are trained on large datasets of medical images, learning to identify patterns and anomalies that might indicate the presence of specific health conditions.

#### Read More

## What are Computational Geometry and Graph Theory Algorithms?

Computational geometry is a branch of computer science devoted to the study of algorithms which can be stated in terms of geometry. It involves the development of algorithms and data structures to solve problems related to geometric objects. These algorithms are crucial for solving a multitude of practical problems that deal with the spatial arrangement of objects, such as finding the shortest path between locations, determining the intersection of various shapes, or computing the closest pair of points. Computational geometry has applications across many fields, including computer graphics, geographic information systems (GIS), robotics, and computer-aided design (CAD). Algorithms in this domain often have to be very efficient because they need to handle large sets of geometric data and produce results in real time or near-real time.

Graph theory algorithms, on the other hand, are centered around the study of graphs, which are mathematical structures used to model pairwise relations between objects. A graph in this context is made up of “vertices” (also called nodes or points) connected by “edges” (also called links or lines). Graph theory algorithms can solve a variety of problems such as finding the most efficient way to route data through a network, identifying the most influential users in a social network, or scheduling tasks in a project. These algorithms form the backbone of many modern systems, including internet routing, social network analysis, and the optimization of transportation networks. Mastery of graph theory algorithms is essential for tackling complex challenges where relationships and interconnectedness are key aspects of the problem.

### Closest Pair of Points on a Plane – D&C

If we’re given a set of points that lie on a plane, how can we figure out which pairs are the closest pair of points on the plane? Let’s try divide & conquer.

### Voronoi Graph and Delaunay Triangulation

Confused by Voronoi Graphs and Delaunay Triangulations? I don’t blame you; even the names sound confusing. But these are difficult names for simple concepts.

### Maximum Independent Set

Given a graph, a subset of the vertices is an independent set if there are no edges between the vertices in the subset. Let’s take a look at a quick example.

### Minimum Vertex Cover

When trying to find the minimum vertex cover, you’re going to be trying to find the minimum number of vertices that will include all the edges. Pretty simple algorithm.

### Maximum Clique

Maximum clique is a technique used to find the largest vertex cluster where each vertex is connected to each other. Let’s find the greatest cluster with this algorithm, visually.

## Thanks for Reading

Thank you for joining me on this explorative journey through the intricate and fascinating world of algorithms. It has been a pleasure to delve into the concepts and applications that are pivotal in the realms of computational geometry and graph theory, among others. Your curiosity and engagement have made this series more than just a collection of topics; they’ve transformed it into a shared adventure in understanding the algorithms that shape our digital world. I hope you’ve found the series enlightening and that it has equipped you with valuable insights and tools for your personal or professional endeavors in computer science. Keep exploring, keep learning, and remember that every algorithm we’ve discussed is a building block for the next innovation—perhaps one that you will pioneer. Thank you for reading, and may your path through the world of algorithms be as rewarding as it is endless.

### Want to Purchase the Book?

You can own this algorithm series in book form, available for purchase on Amazon. It’s a tangible testament to your dedication to learning Algorithms, and a valuable addition to your collection. Plus, it’s priced at the lowest rate Amazon permits – a great deal for such a comprehensive resource!