Algorithms and their properties

Heap select

Description: Similar to quick select, uses partitioning technique of max heap data structure. Time complexity: O(n + k log n) Divide-Conquer Not in-place Stable

Quick Select

Description: Similar to quicksort, it selects a pivot checking if equal to kth element and recursively calls itself until it is equal. Time complexity: Worst case = n^2 Average case = n Best case = n Decrease-Conquer Generally In-place Unstable

Stable Sorting Algorithm

preserves the relative order of any two equal elements in its input

Decrease and Conquer

to recursively reduce a problem to two or more smaller instances of the same problem until the problem can be solved

Divide and Conquer

A program design strategy in which tasks are broken down into subtasks, which are broken down into sub-subtasks, and so on, until each piece is small enough to code comfortably. These pieces work together to accomplish the total job.

Insertion Sort

Description: Best sorting algorithm for small or mostly sorted array. Assumes that element is already partially sorted. Time complexity: Worst case = n^2 Average case = n^2 Best case = n In-place Stable

Sequential sort

Description: Also known as bubble sort, iterates through array, swaps elements if wrong, and continues until no more swaps. Time complexity: O(n^2) Not in-place Stable

Karatsuba's Algorithm

Description: Best for sorting large arrays. Divides array into two halves and sorts them recursively, then merges halves back together. Time complexity: Worst case = n ^ 1.6 Average case = n ^ 1.6 Best case = O(1) Divide-Conquer Not in-place

Merge Sort

Description: Best for sorting large arrays. Divides array into two halves and sorts them recursively, then merges halves back together. Time complexity: Worst case = n log n Average case = n log n Best case = n log n Divide-Conquer Not in-place Stable

Heap sort

Description: Best for sorting large arrays. Divides array into two halves and sorts them recursively, then merges halves back together. Time complexity: Worst case = n log n Average case = n log n Best case = n log n In-place! Not Stable

Heap Sort

Description: Builds binary heap and extracts the maximum element from heap placing it in correct position. Best used for large arrays that do not fit in memory. Time complexity: Worst case = n log n Average case = n log n Best case = n log n In-place Unstable

Timsort

Description: Hybrid algorithm that combines both merge sort and insertion sort. Time complexity: n log n Divide-Conquer Not in-place Stable

Introsort

Description: Hybrid algorithm that uses quicksort, and switches to heapsort when recursion exceeds a certain limit. Time complexity: Best case = n Worst case = n log n Divide-Conquer Not in-place Not Stable

Binary search

Description: It repeatedly divides the array into two halves and checks if the target value is in the left or right half, until the target value is found or the search space is exhausted. Time complexity: Worst case = log n Average case = log n Best case = O(1) Divide-Conquer Not in-place Stable

Grade school algorithm

Description: Multiplication like you did in school where you multiply two numbers by hand. Time complexity: O(n^2)

Radix Sort

Description: Non-comparative sorting algorithm that uses buckets. Useful for fixed digit array. Time complexity: O(kn) Usually not in-place Stable or unstable

Euclid's Algorithm

Description: Recursive algorithm used to find the greatest common divisor of two positive integers. GCD(a, b) = GCD(b, a mod b) Time complexity: Worst case = log n Average case = log n Best case = O(1) Decrease and conquer

Quick Sort

Description: Selects a pivot element, partitions the remaining elements into two sub arrays, and does this term-1recursively until array is sorted. Median of three pivot useful for finding median of an array in linear time. Random pivot useful for avoiding worst case. Time complexity: Worst case = n^2 Average case = n log n Best case = n log n Divide-Conquer In-place Unstable

Topological sort

Description: a graph algorithm that orders the vertices of a directed acyclic graph (DAG) such that for every directed edge (u, v), the vertex u comes before v in the ordering. It is a divide-and-conquer algorithm in the sense that it repeatedly removes a vertex with no incoming edges and its incident edges from the graph, until all vertices have been removed. Time complexity: O(V+E) Divide-Conquer Not in-place Stable

Max-Heapify

Description: calculates the largest integer less than or equal to the square root of a non-negative integer n Time complexity: O(log n)

Integer Square Root

Description: calculates the largest integer less than or equal to the square root of a non-negative integer n Time complexity: Worst case = O(log n) Average case = O(log n) Best case = O(1)

Interpolation search

Description: uses the principle of binary search, but instead of always dividing the search interval in half, it estimates the position of the target value based on its value relative to the values at the endpoints of the interval. Time complexity: Worst case = n Average case = log log n Best case = O(1) Divide-Conquer Not in-place Stable

In place algorithm

does not require significant additional memory to operate and operates directly on the input data.