Khan Academy
GeeksforGeeks
LeetCode
freeCodeCamp.org
The Cherno

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Binary search is like splitting a phonebook in half to find a name. You start in the middle, check if the name you want is before or after, then repeat the process with the half where it could be. This clever strategy means it takes just a few steps to find something, even in a massive phonebook, making it way faster than checking every name one by one.

Binary search doesn't need much space to work. It's like having a small notebook where you write down a few things as you search. No matter how big the phonebook is, you only need that one little notebook. So, it doesn't matter if you're searching through a tiny or giant phonebook—it's always the same amount of extra stuff you need.

Khan Academy - Interactive exercises and visualizations to grasp BFS concepts
GeeksforGeeks - Detailed explanation, code examples in various languages, and complexity analysis
Visualgo - Interactive animation to visualize the BFS process
The Coding Train - Engaging video explanation with clear visualizations freeCodeCamp.org - Concise and practical explanation

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

BFS explores a graph in a level-by-level fashion. It starts by visiting all the neighbors of the starting node, then all the neighbors of those neighbors, and so on, until all reachable nodes have been explored.

BFS typically uses a queue data structure to keep track of the nodes to be explored. Nodes are added to the back of the queue and processed in a First-In-First-Out (FIFO) manner.

Khan Academy - Interactive exercises and visualizations to grasp BFS concepts
GeeksforGeeks - Detailed explanation, code examples in various languages, and complexity analysis
Visualgo - Interactive animation to visualize the BFS process
The Coding Train - Engaging video explanation with clear visualizations
freeCodeCamp.org - Concise and practical explanation

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

DFS explores a graph in a depth-first manner. It starts at a node and explores as far as possible along a chosen path, backtracking and exploring other branches when it reaches a dead end (unvisited neighbor with no unexplored paths).

DFS typically uses a stack data structure to keep track of the nodes to be explored. Nodes are pushed onto the stack and explored in a Last-In-First-Out (LIFO) manner. This ensures that DFS explores a single path deeply before moving on to other branches.

Khan Academy - Interactive exercises and visualizations to grasp BFS concepts
GeeksforGeeks - Detailed explanation, code examples in various languages, and complexity analysis
Visualgo - Interactive animation to visualize the BFS process
The Coding Train - Engaging video explanation with clear visualizations
freeCodeCamp.org - Concise and practical explanation

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Merge Sort is a divide-and-conquer sorting algorithm. It works by recursively dividing the unsorted list into sub-lists containing a single element (which are inherently sorted). Then, it repeatedly merges adjacent sub-lists to produce new sorted sub-lists until the entire list is merged into a single sorted list.

Divide: Recursively divide the unsorted list into sub-lists containing a single element each.
Conquer: Sort the individual sub-lists (these sub-lists of size 1 are already sorted).
Merge: Merge the sorted sub-lists back together in a way that preserves the sorted order. This merging process continues until the entire list is sorted.

Mozilla Developer Network (MDN) - Explanation and code examples
GeeksforGeeks - Detailed explanation, code examples in various languages, and complexity analysis
CS Dojo - Interactive animation to visualize the Quicksort process
The Coding Train - Engaging video explanation with clear visualizations
freeCodeCamp.org - Concise and practical explanation

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Quicksort is a divide-and-conquer sorting algorithm that relies on a partitioning strategy. It selects a pivot element from the list and rearranges the elements such that all elements smaller than the pivot are placed before it, and all elements greater than the pivot are placed after it. The sub-lists on either side of the pivot are then sorted recursively, resulting in a sorted entire list.

Choose a pivot: Select a pivot element from the list (different strategies can be used for pivot selection).
Partition: Rearrange the list elements such that elements less than the pivot are placed to its left and elements greater than the pivot are placed to its right.
Recursively Sort: Recursively sort the sub-lists on either side of the pivot

Wikipedia - Formal definition and properties
GeeksforGeeks - Detailed explanation, code examples, and complexity analysis
Visualgo - Interactive animation to visualize Kruskal's process
The Coding Train - Engaging video explanation with clear visualizations
freeCodeCamp.org - Concise and practical explanation

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Kruskal's Algorithm finds a minimum spanning tree (MST) for a weighted, connected, undirected graph. An MST is a subset of the graph's edges that connects all its vertices with the least possible total edge weight. It ensures that there are no cycles and covers every vertex in the graph.

To construct a minimum spanning tree (MST) from a graph, start by sorting all edges by weight. Initialize a forest where each vertex is a single-vertex tree. Iterate through the sorted edges, adding an edge to the MST if it connects vertices from different trees, merging the trees. Discard edges that would create cycles. Repeat until all vertices are connected in a single tree, forming the MST.

Wikipedia - Detailed explanation and properties
Programiz - Clear explanation, code examples, and complexity analysis
CS Dojo - You can find videos explaining Floyd-Warshall's algorithm here

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Floyd-Warshall Algorithm efficiently finds the shortest paths between all pairs of vertices in a weighted graph, even with negative edge weights (unlike Dijkstra's algorithm). It achieves this through a dynamic programming approach.

To initialize, create a distance matrix D where each entry D[i][j] holds the shortest known distance between vertex i and vertex j, initially filled with edge weights (infinity for non-existent edges). Then, iteratively update distances by considering intermediate vertices k, checking if a path through k offers a shorter distance between vertices i and j, and updating D[i][j] accordingly. Repeat for a fixed number of iterations equal to the number of vertices in the graph.

Khan Academy - Interactive exercises and visualizations
GeeksforGeeks - Detailed explanation, code examples
Visualgo - Interactive animation
The Coding Train: (Engaging video explanation) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Dijkstra's Algorithm efficiently finds the shortest paths from a single source vertex to all other vertices in a weighted, non-negative graph. It prioritizes exploring paths with the least cumulative weight encountered so far.

In essence, the algorithm maintains a set of visited nodes and a distance array. It iteratively selects the unvisited node with the minimum distance from the source, marks it as visited, and updates distances to its unvisited neighbors if a shorter path is found through the current node. This process continues until all nodes are visited, resulting in the shortest distances from the source to all other reachable vertices.

Mozilla Developer Network (MDN) - Explanation related to sorting algorithms, but applicable to Bellman-Ford for understanding its time complexity
GeeksforGeeks: (Detailed explanation, code examples) [invalid URL removed]
CS Dojo - You can find videos explaining Bellman-Ford's algorithm here

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Bellman-Ford is a single-source shortest path algorithm that works for weighted graphs, even those with negative edge weights (unlike Dijkstra's algorithm). It tackles this by iteratively relaxing edges, ensuring no shorter paths are missed.

The algorithm works in rounds, relaxing each edge in the graph a specific number of times (equal to the number of vertices). In each relaxation step, it checks if a shorter path exists by going through a particular vertex. This process guarantees finding the shortest paths if no negative-weight cycles are present. pen_spark If a negative-weight cycle exists, the algorithm detects it.

Mozilla Developer Network (MDN) - Explanation related to sorting algorithms, but applicable to Bellman-Ford for understanding its time complexity
GeeksforGeeks - Explanation related to sorting algorithms, but applicable to Bellman-Ford for understanding its time complexity
CS Dojo - You can find videos explaining Bellman-Ford's algorithm here

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Kadane's Algorithm efficiently finds the maximum sum contiguous subarray within a given array of numbers. It works by iterating through the array and keeping track of two key variables:

Current Subarray Sum (max_ending_here): This variable stores the maximum sum of a subarray ending at the current element.
Maximum Subarray Sum So Far (max_so_far): This variable keeps track of the overall maximum subarray sum encountered so far.

At each step, the algorithm considers the current element and the current subarray sum. It updates the current subarray sum by either taking the element itself (if negative) or adding it to the previous subarray sum (if positive). The maximum subarray sum so far is then updated if the current subarray sum is greater. This process ensures finding the subarray with the maximum possible sum.

GeeksforGeeks: While Lee Algorithm isn't directly covered for shortest paths, A* search shares similar pathfinding concepts
CodeDope

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Lee Algorithm is a pathfinding technique often used in maze routing problems. It finds the shortest path from a starting point to an end point within a grid-based maze. The algorithm works based on a breadth-first search (BFS) approach.

Start with the source point: The algorithm begins by placing the starting point in a queue.
Iterative Exploration: It iteratively removes a cell from the queue and explores its four unvisited neighbors (up, down, left, right).
Marking and Enqueuing: If a neighbor is a valid path (not a wall), it's marked as visited and added to the queue for further exploration. The distance from the source point is also assigned to the neighbor.
Repeat until destination is reached: This exploration process continues until the destination point is removed from the queue. The recorded distances then indicate the shortest path from the starting point to the end point.

Wikipedia - Formal definition and properties
Baeldung: (Detailed explanation with code examples) Reddit
CS Dojo - Interactive animation to visualize Flood Fill
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Flood Fill replaces a target color with a replacement color in a connected area, starting from a seed point. It explores neighboring pixels/nodes recursively or iteratively, replacing the target color with the new color and continuing until all connected pixels/nodes with the target color are filled.

Flood Fill is used in various applications like:
Paint tools for digital art and image editing
Filling closed shapes in games
Identifying connected components in graphs

Wikipedia - Explanation within the Cycle Detection section
CS Dojo - You can find videos explaining Floyd's Cycle Detection Algorithm here

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Floyd's Cycle Detection Algorithm, also known as the Tortoise and Hare Algorithm, efficiently determines if a cycle exists in a linked list. It uses two pointers, a slow pointer (often called the tortoise) and a fast pointer (often called the hare), that traverse the linked list at different speeds.

Initialization: Begin with both pointers (slow and fast) at the head of the linked list.
Iterative Movement: In each iteration, advance the slow pointer by one node and the fast pointer by two nodes if possible.
Cycle Detection: If the fast pointer meets the slow pointer, a cycle exists; otherwise, if the fast pointer reaches the end of the list, there's no cycle.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Detailed explanation, code examples
CS Dojo - You can find videos explaining Union-Find Algorithm here
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

The Union-Find Algorithm, also known as the Disjoint-Set Data Structure, manages a collection of disjoint sets (non-overlapping groups). It efficiently performs two main operations:
Union (Merge): This operation combines two sets into a single set. The algorithm efficiently merges the smaller tree (based on a certain criterion) into the larger tree to maintain efficiency.
Find (Root): This operation determines which set a particular element belongs to by finding the root element of the tree that element resides in.

Each element belongs to a set represented by a tree structure, where each node points to its parent (except the root, which has no parent).
The Union operation finds the root nodes of the two sets to be merged.
It then connects one tree's root to the other tree's root (usually the shallower tree's root is attached to the deeper tree's root).
The Find operation recursively follows parent pointers until it reaches the root node, which identifies the set an element belongs to.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Clear explanation, code examples
Interview Cake - Focuses on intuition and applications
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

Topological Sort arranges a directed acyclic graph (DAG) into a linear order. In this order, for every directed edge from node u to node v, u comes before v. Imagine it as scheduling tasks with dependencies - a task can't be started before its dependent tasks are completed.

Prepending ensures that nodes with no incoming edges (independent tasks) are placed at the end of the list, and dependent nodes are placed earlier. This creates a valid topological order where all dependencies are satisfied.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Detailed explanation, code examples
Visualgo - Interactive animation
The Coding Train: [invalid URL removed] (Engaging video explanation with clear visualizations)
freeCodeCamp.org: (Concise and practical explanation) YouTube

Coursera: "Algorithms, Part 1" by Stanford University
edX: "Introduction to Algorithms" by MIT

The KMP Algorithm is a string searching algorithm that efficiently finds occurrences of a pattern string P within a longer text string T. It improves upon the naive search approach by utilizing information gained from partial matches to avoid redundant comparisons.

KMP algorithm builds a prefix table storing the longest proper prefix which is also a suffix for each pattern index. During pattern matching, two pointers traverse the text and pattern. If characters match, both pointers advance; if a mismatch occurs, the pattern pointer is shifted back based on the prefix table. When the pattern pointer reaches the end, a match is found in the text at the corresponding index.

Start with the second element: Consider the second element in the list as the first element of the sorted sub-list.
Iterate through the unsorted part:
Compare the current element with its previous element in the sorted sub-list.
If the current element is less than the previous element:
Shift the larger elements in the sorted sub-list one position up (to make space for the current element).
Insert the current element at its correct position in the sorted sub-list.
Repeat for all unsorted elements: Continue iterating through the list, comparing and potentially inserting each element into its correct position within the growing sorted sub-list.

Average and Worst Case: O(n^2) - This is because in the worst case scenario (e.g., the list is already sorted in descending order), each element needs to be compared and potentially shifted, leading to a quadratic number of comparisons.
Best Case: O(n) - If the list is already sorted in ascending order, only comparisons are needed, resulting in linear time complexity.

Simple to understand and implement.
Efficient for small lists.
Performs well for partially sorted data (already nearly in order).
Uses minimal extra space (in-place sorting).

Quadratic time complexity in the worst and average cases.
Not suitable for very large datasets due to its inefficiency.

Wikipedia - Formal definition and properties
GeeksforGeeks - Detailed explanation, code examples
Khan Academy - Interactive tutorial with visualization
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Average and Worst Case: O(n^2) - Similar to Insertion Sort, Selection Sort requires quadratic comparisons in the worst case (e.g., descending order) and on average. Each element needs to be compared with others to find the minimum in each iteration.
Best Case: O(n) - If the list is already sorted in ascending order, only comparisons are needed, resulting in linear time complexity.

Simple to understand and implement.
Efficient for small lists.
Performs well for partially sorted data (already nearly in order).
Uses minimal extra space (in-place sorting).

Quadratic time complexity in the worst and average cases.
Not suitable for very large datasets due to its inefficiency.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Explanation with code examples
Programiz - Detailed explanation with animation
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Counting Sort is a non-comparison based sorting algorithm, meaning it doesn't rely on element comparisons for sorting.
It excels when the range of values is limited compared to the number of elements. This is because the size of the count_array is directly tied to the value range.
Counting Sort has a time complexity of O(n + r), where n is the number of elements and r is the range of values. This makes it efficient for specific use cases.

The algorithm starts by determining the largest element in the input list and then constructs a count array to store the frequency of each unique value. By iterating through the original list, it tallies the occurrences of each element in the count array. Subsequently, a prefix sum operation is applied to the count array to compute the sorted position of each element. In the final step, the algorithm traverses the original list in reverse order, utilizing the counts from the prefix sum to position each element in the output array, while ensuring duplicates are handled appropriately by decrementing the counts.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Explanation with code examples
Programiz - Detailed explanation with animation
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Average and Worst Case: O(n log n) - Heap Sort has a favorable time complexity, making it efficient for large datasets. Building the heap and repeated heapify operations contribute to the logarithmic factor.

Efficient for sorting large datasets due to its O(n log n) time complexity.
In-place sorting, meaning it sorts the data within the original array without requiring significant extra space.
Versatile - Can be modified for heap-based priority queues, useful for retrieving the element with the highest (or lowest) priority.

Not as simple to understand or implement compared to some other sorting algorithms like Selection Sort or Insertion Sort.
Overhead of maintaining the heap structure can be slightly higher compared to simpler sorting methods.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Clear explanation, code examples
Interview Cake - Focuses on intuition and applications
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

O(V + E) - This represents linear time complexity in terms of the number of vertices (V) and edges (E) in the DAG. The in-degree calculation and queue operations contribute to this efficiency.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Explanation with code examples
Programiz - Detailed explanation with animation
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Decompressing Huffman-coded data requires the original Huffman tree or the code table derived from the tree. By following the assigned bits (0s and 1s) and traversing the tree based on the bits (left for 0, right for 1), the decompressing process can identify the original symbols and reconstruct the original data.

Efficiency: Huffman Coding is efficient for data with skewed symbol frequencies, where some characters appear much more often than others.
Lossless Compression: It preserves the original data perfectly, making it suitable for scenarios where data integrity is crucial.
Simplicity: The underlying concept and implementation are relatively straightforward compared to some other compression techniques.

Variable Length Codes: The use of variable-length codes makes it slightly more complex to process compared to fixed-length coding schemes.
Overhead: In some cases, additional information about the Huffman tree might need to be stored along with the compressed data, introducing some overhead.
Limited to Statistical Redundancy: It primarily targets redundancy based on symbol frequencies, and may not be as effective for other types of data redundancy.

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Clear explanation with code examples
Khan Academy - Interactive explanation with visualizations
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Quickselect is an in-place algorithm, meaning it modifies the original list.
It has an average and worst-case time complexity of O(n), which is significantly better than selection-based algorithms like Selection Sort with O(n^2) complexity.
The random selection of the pivot element helps achieve the average-case O(n) complexity by avoiding consistently bad pivots that might lead to imbalanced partitions.

Efficient for finding the kth smallest (or largest) element in an unsorted list.
Faster than selection-based algorithms on average due to O(n) time complexity.
Relatively simple to understand and implement.

Worst-case time complexity can be O(n^2) in situations with a consistently bad pivot choice.
Not suitable for full list sorting (focuses on finding a specific element position).

Wikipedia - Detailed explanation and properties
GeeksforGeeks - Clear explanation with code examples
Programiz - Explanation with animation
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

O(n) - The algorithm iterates through the list only once in the worst case.

O(1) - It uses constant extra space for the candidate and count variables.

Efficient linear time complexity (O(n)).
Low space complexity (O(1)), making it memory-efficient.
Simple to understand and implement.

Only works for finding the majority element (assuming it exists).
Doesn't provide information about the frequency of the majority element or other elements.
The verification pass might be needed to confirm the majority, adding a slight overhead.

Wikipedia - Detailed explanation and properties
Khan Academy - Step-by-step explanation with video
GeeksforGeeks - Explanation with code examples
The Coding Train: (Engaging video explanation with clear visualizations) YouTube
freeCodeCamp.org: (Concise and practical explanation) YouTube

Euclid's Algorithm has a time complexity of O(log min(a, b)), where min(a, b) represents the smaller of the two input integers. This makes it efficient for finding the GCD of large numbers.

Euclid's Algorithm has various applications in cryptography, number theory, and other areas of mathematics.
It is used in algorithms like the Extended Euclidean Algorithm for finding the modular inverse of a number.

The key idea is that the GCD of two numbers also divides their difference. For example, if the GCD of 210 and 45 is 15, then 15 must also divide 210 - 45 (which is 165). By repeatedly replacing the larger number with its difference from the smaller number, we eventually reach a point where the larger number becomes a multiple of the smaller number. The remainder at that point becomes the GCD.