Algorithm Review
@algorithmreview.bsky.social
Helpful posts about computer science algorithms, data structures, and more. Please DM any corrections.
Radix sort is a non-comparative integer sorting algorithm that processes individual digits of numbers, starting from the least significant digit to the most significant.
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
November 12, 2025 at 1:45 PM
Radix sort is a non-comparative integer sorting algorithm that processes individual digits of numbers, starting from the least significant digit to the most significant.
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
Radix sort is a non-comparative integer sorting algorithm that processes individual digits of numbers, starting from the least significant digit to the most significant.
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
November 11, 2025 at 1:44 PM
Radix sort is a non-comparative integer sorting algorithm that processes individual digits of numbers, starting from the least significant digit to the most significant.
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
Quick sort is a fast, divide-and-conquer sorting algorithm that selects a pivot element and partitions the list into sublists of elements less than and greater than the pivot.
• Time complexity: O(n^2) (worst), O(n log n) (average)
• Space complexity: O(log n)
#AlgorithmReview
• Time complexity: O(n^2) (worst), O(n log n) (average)
• Space complexity: O(log n)
#AlgorithmReview
November 10, 2025 at 1:44 PM
Quick sort is a fast, divide-and-conquer sorting algorithm that selects a pivot element and partitions the list into sublists of elements less than and greater than the pivot.
• Time complexity: O(n^2) (worst), O(n log n) (average)
• Space complexity: O(log n)
#AlgorithmReview
• Time complexity: O(n^2) (worst), O(n log n) (average)
• Space complexity: O(log n)
#AlgorithmReview
Breadth-First Search (BFS) is a graph traversal algorithm that explores all neighbors at the current depth before moving on to nodes at the next depth level.
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
November 9, 2025 at 1:40 PM
Breadth-First Search (BFS) is a graph traversal algorithm that explores all neighbors at the current depth before moving on to nodes at the next depth level.
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
Bucket sort is a distribution sort that works well when input is uniformly distributed that divides the elements into several buckets, sorts each bucket, and then merges them.
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
November 8, 2025 at 1:39 PM
Bucket sort is a distribution sort that works well when input is uniformly distributed that divides the elements into several buckets, sorts each bucket, and then merges them.
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
Counting sort is a non-comparison-based sorting algorithm suitable for small, non-negative integer ranges that counts the occurrences of each element and uses this information to place elements in the correct position.
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
November 7, 2025 at 1:42 PM
Counting sort is a non-comparison-based sorting algorithm suitable for small, non-negative integer ranges that counts the occurrences of each element and uses this information to place elements in the correct position.
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
November 6, 2025 at 1:44 PM
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
November 5, 2025 at 1:45 PM
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
November 4, 2025 at 1:46 PM
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
Counting sort is a non-comparison-based sorting algorithm suitable for small, non-negative integer ranges that counts the occurrences of each element and uses this information to place elements in the correct position.
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
November 3, 2025 at 1:44 PM
Counting sort is a non-comparison-based sorting algorithm suitable for small, non-negative integer ranges that counts the occurrences of each element and uses this information to place elements in the correct position.
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(k)
#AlgorithmReview
Selection sort is a simple comparison-based sorting algorithm that repeatedly selects the minimum element from the unsorted part and moves it to the sorted part.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
November 2, 2025 at 1:39 PM
Selection sort is a simple comparison-based sorting algorithm that repeatedly selects the minimum element from the unsorted part and moves it to the sorted part.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
Binary Search is an efficient algorithm for finding an item from a sorted list that repeatedly divides the search interval in half until the target value is found.
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
November 1, 2025 at 1:39 PM
Binary Search is an efficient algorithm for finding an item from a sorted list that repeatedly divides the search interval in half until the target value is found.
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
Bubble sort is a simple but inefficient sorting algorithm that repeatedly compares adjacent elements in a list, swapping them if they are out of order.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
October 31, 2025 at 1:43 PM
Bubble sort is a simple but inefficient sorting algorithm that repeatedly compares adjacent elements in a list, swapping them if they are out of order.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
Heap sort (in-place) is a comparison-based sorting algorithm using a binary heap data structure that repeatedly removes the root (largest or smallest element depending on the heap type) and maintains the heap property.
• Time complexity: O(n log n)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n log n)
• Space complexity: O(1)
#AlgorithmReview
October 30, 2025 at 1:44 PM
Heap sort (in-place) is a comparison-based sorting algorithm using a binary heap data structure that repeatedly removes the root (largest or smallest element depending on the heap type) and maintains the heap property.
• Time complexity: O(n log n)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n log n)
• Space complexity: O(1)
#AlgorithmReview
Knapsack Problem (0/1) is a dynamic programming algorithm for solving the knapsack problem that determines the maximum value that can be obtained without exceeding the weight capacity.
• Time complexity: O(nW)
• Space complexity: O(nW)
#AlgorithmReview
• Time complexity: O(nW)
• Space complexity: O(nW)
#AlgorithmReview
October 29, 2025 at 1:46 PM
Knapsack Problem (0/1) is a dynamic programming algorithm for solving the knapsack problem that determines the maximum value that can be obtained without exceeding the weight capacity.
• Time complexity: O(nW)
• Space complexity: O(nW)
#AlgorithmReview
• Time complexity: O(nW)
• Space complexity: O(nW)
#AlgorithmReview
Bucket sort is a distribution sort that works well when input is uniformly distributed that divides the elements into several buckets, sorts each bucket, and then merges them.
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
October 28, 2025 at 1:44 PM
Bucket sort is a distribution sort that works well when input is uniformly distributed that divides the elements into several buckets, sorts each bucket, and then merges them.
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(n + k)
• Space complexity: O(n + k)
#AlgorithmReview
Bubble sort is a simple but inefficient sorting algorithm that repeatedly compares adjacent elements in a list, swapping them if they are out of order.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
October 27, 2025 at 1:45 PM
Bubble sort is a simple but inefficient sorting algorithm that repeatedly compares adjacent elements in a list, swapping them if they are out of order.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
Selection sort is a simple comparison-based sorting algorithm that repeatedly selects the minimum element from the unsorted part and moves it to the sorted part.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
October 26, 2025 at 1:39 PM
Selection sort is a simple comparison-based sorting algorithm that repeatedly selects the minimum element from the unsorted part and moves it to the sorted part.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
Breadth-First Search (BFS) is a graph traversal algorithm that explores all neighbors at the current depth before moving on to nodes at the next depth level.
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
October 25, 2025 at 1:39 PM
Breadth-First Search (BFS) is a graph traversal algorithm that explores all neighbors at the current depth before moving on to nodes at the next depth level.
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
• Time complexity: O(V + E)
• Space complexity: O(V)
#AlgorithmReview
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
October 24, 2025 at 1:44 PM
Floyd-Warshall is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights that uses dynamic programming to update the shortest paths between all pairs of vertices.
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
• Time complexity: O(V^3)
• Space complexity: O(V^2)
#AlgorithmReview
Insertion sort is a simple sorting algorithm suitable for small datasets that builds the final sorted array one item at a time, inserting elements into their correct position.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
October 23, 2025 at 1:45 PM
Insertion sort is a simple sorting algorithm suitable for small datasets that builds the final sorted array one item at a time, inserting elements into their correct position.
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(n^2)
• Space complexity: O(1)
#AlgorithmReview
Radix sort is a non-comparative integer sorting algorithm that processes individual digits of numbers, starting from the least significant digit to the most significant.
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
October 22, 2025 at 1:46 PM
Radix sort is a non-comparative integer sorting algorithm that processes individual digits of numbers, starting from the least significant digit to the most significant.
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
• Time complexity: O(d * (n + k))
• Space complexity: O(n + k)
#AlgorithmReview
Merge sort is an efficient, stable, divide-and-conquer sorting algorithm that recursively divides the list into halves, sorts each half, and merges them back together.
• Time complexity: O(n log n)
• Space complexity: O(n)
#AlgorithmReview
• Time complexity: O(n log n)
• Space complexity: O(n)
#AlgorithmReview
October 21, 2025 at 1:46 PM
Merge sort is an efficient, stable, divide-and-conquer sorting algorithm that recursively divides the list into halves, sorts each half, and merges them back together.
• Time complexity: O(n log n)
• Space complexity: O(n)
#AlgorithmReview
• Time complexity: O(n log n)
• Space complexity: O(n)
#AlgorithmReview
Binary Search is an efficient algorithm for finding an item from a sorted list that repeatedly divides the search interval in half until the target value is found.
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
October 20, 2025 at 1:43 PM
Binary Search is an efficient algorithm for finding an item from a sorted list that repeatedly divides the search interval in half until the target value is found.
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
• Time complexity: O(log n)
• Space complexity: O(1)
#AlgorithmReview
Dijkstra's Algorithm is an algorithm for finding the shortest paths between nodes in a graph that maintains a priority queue to explore the shortest known distance to each vertex.
• Time complexity: O((V + E) log V)
• Space complexity: O(V)
#AlgorithmReview
• Time complexity: O((V + E) log V)
• Space complexity: O(V)
#AlgorithmReview
October 19, 2025 at 1:39 PM
Dijkstra's Algorithm is an algorithm for finding the shortest paths between nodes in a graph that maintains a priority queue to explore the shortest known distance to each vertex.
• Time complexity: O((V + E) log V)
• Space complexity: O(V)
#AlgorithmReview
• Time complexity: O((V + E) log V)
• Space complexity: O(V)
#AlgorithmReview