Skip to content

Time and Space Complexity Analysis of Merge Sort

Time Complexities of all Sorting Algorithms

Last Updated : 19 Mar, 2025

The efficiency of an algorithm depends on two parameters:

Time Complexity
Auxiliary Space

Both are calculated as the function of input size(n). One important thing here is that despite these parameters, the efficiency of an algorithm also depends upon the nature and size of the input.

Time Complexity:

Time Complexity is defined as order of growth of time taken in terms of input size rather than the total time taken. It is because the total time taken also depends on some external factors like the compiler used, the processor’s speed, etc.

Auxiliary Space:

Auxiliary Space is extra space (apart from input and output) required for an algorithm.

Types of Time Complexity :

Best Time Complexity: Define the input for which the algorithm takes less time or minimum time. In the best case calculate the lower bound of an algorithm. Example: In the linear search when search data is present at the first location of large data then the best case occurs.
Average Time Complexity: In the average case take all random inputs and calculate the computation time for all inputs.
And then we divide it by the total number of inputs.
Worst Time Complexity: Define the input for which algorithm takes a long time or maximum time. In the worst calculate the upper bound of an algorithm. Example: In the linear search when search data is present at the last location of large data then the worst case occurs.

Following is a quick revision sheet that you may refer to at the last minute:

Algorithm	Time Complexity			Auxiliary Space
	Best	Average	Worst	Worst
Selection Sort	O(n²)	O(n²)	O(n²)	O(1)
Bubble Sort	O(n)	O(n²)	O(n²)	O(1)
Insertion Sort	O(n)	O(n²)	O(n²)	O(1)
Heap Sort	O(n log(n))	O(n log(n))	O(n log(n))	O(1)
Quick Sort	O(n log(n))	O(n log(n))	O(n²)	O(n)
Merge Sort	O(n log(n))	O(n log(n))	O(n log(n))	O(n)
Bucket Sort	O(n +k)	O(n +k)	O(n²)	O(n)
Radix Sort	O(nk)	O(nk)	O(nk)	O(n + k)
Count Sort	O(n +k)	O(n +k)	O(n +k)	O(k)
Shell Sort	O(n log(n))	O(n log(n))	O(n²)	O(1)
Tim Sort	O(n)	O(n log(n))	O(n log (n))	O(n)
Tree Sort	O(n log(n))	O(n log(n))	O(n²)	O(n)
Cube Sort	O(n)	O(n log(n))	O(n log(n))	O(n)

Also, see:

Time and Space Complexity Analysis of Merge Sort

kartik

Improve

Article Tags :

Practice Tags :

Sorting

Similar Reads

Time and Space complexity of Radix Sort Algorithm

The Radix Sort Algorithm has a time complexity of O(n*d), where n is the number of elements in the input array and d is the number of digits in the largest number. The space complexity of Radix Sort is O(n + k), where n is the number of elements in the input array and k is the range of the input. Th

The Slowest Sorting Algorithms

A Sorting Algorithm is used to rearrange a given array or list elements according to a comparison operator on the elements. The comparison operator is used to decide the new order of the element in the respective data structure. But Below is some of the slowest sorting algorithms: Stooge Sort: A Sto

Classification of Sorting Algorithms

Sorting is an algorithm which arranges the elements of a given list in a particular order [ascending or descending]. Sorting algorithms are categorized on the following basis - By number of comparisons :Comparison-based sorting algorithms check the elements of the list by key comparison operation an

Time and Space Complexity Analysis of Kruskal Algorithm

Kruskal's algorithm is a popular algorithm for finding the Minimum Spanning Tree (MST) of a connected, undirected graph. The time complexity of Kruskal's algorithm is O(E log E), where E is the number of edges in the graph. The space complexity of Kruskal's algorithm is O(V + E), where V is the numb

Time and Space Complexity Analysis of Merge Sort

The Time Complexity of Merge Sort is O(n log n) in both the average and worst cases. The space complexity of Merge sort is O(n). AspectComplexityTime ComplexityO(n log n)Space ComplexityO(n)Time Complexity Analysis of Merge Sort:Consider the following terminologies: T(k) = time taken to sort k eleme

Time and Space Complexity Analysis of Bubble Sort

The time complexity of Bubble Sort is O(n^2) in the worst-case scenario and the space complexity of Bubble sort is O(1). Bubble Sort only needs a constant amount of additional space during the sorting process. Complexity TypeComplexityTime ComplexityBest: O(n)Average: O(n^2)Worst: O(n^2)Space Comple

Time and Space Complexity Analysis of Quick Sort

The time complexity of Quick Sort is O(n log n) on average case, but can become O(n^2) in the worst-case. The space complexity of Quick Sort in the best case is O(log n), while in the worst-case scenario, it becomes O(n) due to unbalanced partitioning causing a skewed recursion tree that requires a

Can Run Time Complexity of a comparison-based sorting algorithm be less than N logN?

Sorting algorithms are the means to sort a given set of data in an order according to the requirement of the user. They are primarily used to sort data in an increasing or decreasing manner. There are two types of sorting algorithms: Comparison-based sorting algorithmsNon-comparison-based sorting al

Asymptotic Analysis and comparison of sorting algorithms

It is a well established fact that merge sort runs faster than insertion sort. Using asymptotic analysis. we can prove that merge sort runs in O(nlogn) time and insertion sort takes O(n^2). It is obvious because merge sort uses a divide-and-conquer approach by recursively solving the problems where

When to use each Sorting Algorithms | Set 2

Sorting is the process of arranging a set of data in a specific order, which may be numerical (ascending, descending) or lexicographical (alphabetical) order. Why Sorting Is Required? Sorting is very essential when there is a need to highly optimize the searching algorithm. For example, let's assume