Logarithmic Time Complexity - A Complete Tutorial

Logarithmic time complexity is denoted as O(log n). It is a measure of how the runtime of an algorithm scales as the input size increases. In this comprehensive tutorial.

What is a Logarithm? The power to which a base needs to be raised to reach a given number is called the logarithm of that number for the respective base. For finding logarithmic two necessary factors that need to be known are base and number.

👁 What is a logarithm

Examples:

logarithm of 8 for base 2 = log₂(8) = 3, 
Explanation: 2³= 8 Since 2 needs to be raised to a power of 3 to give 8, Thus logarithm of 8 base 2 is 3.

logarithm of 81 for base 9 = log₉(81) = 2,
Explanation: 9²= 81 Since 9 needs to be raised to a power of 2 to give 81, Thus logarithm of 81 base 9 is 2.

Note: An exponential function is the exact opposite of a logarithmic function. When a value is being multiplied repeatedly it is said to grow exponentially whereas when the value is being divided repeatedly it is said to grow logarithmically.

Different Types of Logarithmic Complexities

Now that we know what is a logarithm, let's deep dive into different types of logarithmic complexities that exists, such as:

Simple Log Complexity (Log_a b)

Simple logarithmic complexity refers to log of b to the base a. As mentioned, it refers to the time complexity in terms of base a. In design and analysis of algorithms, we generally use 2 as the base for log time complexities. The below graph shows how the simple log complexity behaves.

 There are several standard algorithms that have logarithmic time complexity:

• Merge sort
• Binary search
• Heap sort

Double Logarithm (log log N)

Double logarithm is the power to which a base must be raised to reach a value 'x' such that when the base is raised to a power 'x' it reaches a value equal to given number.

Example:

logarithm (logarithm (256)) for base 2 = log₂(log₂(256)) = log₂(8) = 3. 

Explanation: 2⁸= 256, Since 2 needs to be raised to a power of 8 to give 256, Thus logarithm of 256 base 2 is 8. Now 2 needs to be raised to a power of 3 to give 8 so log₂(8) = 3.

N logarithm N (N * log N)

N*logN complexity refers to product of N and log of N to the base 2. N * log N time complexity is generally seen in sorting algorithms like Quick sort, Merge Sort, Heap sort. Here N is the size of data structure (array) to be sorted and log N is the average number of comparisons needed to place a value at its right place in the sorted array. 

logarithm² N (log² N)

log² N complexity refers to square of log of N to the base 2. 

N² logarithm N (N² * log N)

N²*log N complexity refers to product of square of N and log of N to the base 2. This Order of time complexity can be seen in case where an N * N * N 3D matrix needs to be sorted along the rows. The complexity of sorting each row would be N log N and for N rows it will be N * (N * log N). Thus the complexity will be N² log N,

N³ logarithm N (N³ log N)

N³*log N complexity refers to product of cube of N and log of N to the base 2. This Order of time complexity can be seen in cases where an N * N matrix needs to be sorted along the rows. The complexity of sorting each row would be N log N and for N rows it will be N * (N * log N) and for N width it will be N * N * (N log N). Thus the complexity will be N³ log N,

logarithm √N (log √N)

log √N complexity refers to log of square root of N to the base 2.

Examples To Demonstrate Logarithmic Time Complexity

Example 1: log_a b

Task: We have a number N which has an initial value of 16 and the task is to reduce the given number to 1 by repeated division of 2. 
Approach:

• Initialize a variable number_of_operation with a value 0 .
• Run a for loop from N till 1.
  • In each iteration reduce the value of N to half.
  • Increment the number_of_operation variable by one.
• Return the number_of_operation variable.

Implementation:

Logarithmic reduction of N: 16 8 4 2 
Algorithm Runtime for reducing N to 1: 4

Explanation:

It is clear from the above algorithm that in each iteration the value is divided by a factor of 2 starting from 16 till it reaches 1, it takes 4 operations. 

As the input value gets reduced by a factor of 2, In mathematical terms the number of operations required in this case is log₂(N), i.e. log₂(16) = 4.So, in terms of time complexity, the above algorithm takes logarithmic runtime to complete i.e.  log₂(N). 

Example 2: Binary search algorithm (log N)

Linearly Searching a value in an array of size N can be very hectic, even when the array is sorted but using binary search this can be done in a lot easier way and in lesser time as the algorithm reduces the search space by half in each operation thus gives a complexity of log₂(N), Here base is 2 because process repeatedly reduces to half. 

Consider an array Arr[] = {2, 4, 6, 8, 10, 12, 14, 16, 18}, If it is required to find the index of 8 then the algorithm will work as following:

8 was present on index: 3
Algorithm Runtime: 1

Explanation:

Binary search works on Divide and conquer approach, In above example In worst case 3 comparisons will be needed to find any value in array. Also the value of log (N) where N is input size i.e. 8 for above example will be 3. Hence the algorithm can be said to exhibit logarithmic time complexity.

Example 3: Binary search algorithm (log log N)

An example where the time complexity of algorithm is Double logarithmic along with a length factor N is when prime numbers from 1 to N need to be found. 

2 3 5 7 11 

In above example the complexity of finding prime numbers in a range of 0 to N is O(N * log (log (N))). 

Practice Problems for Logarithmic Time Complexity

Comparison of various Logarithmic Time Complexities

Below is a graph to show the comparison between different logarithmic time complexities that have been discussed above: