# What does O(log n) mean exactly?

## What does O(log n) mean exactly?

### Question

I am learning about Big O Notation running times and amortized times. I understand the notion of *O(n)* linear time, meaning that the size of the input affects the growth of the algorithm proportionally...and the same goes for, for example, quadratic time *O(n ^{2})* etc..even algorithms, such as permutation generators, with

*O(n!)*times, that grow by factorials.

For example, the following function is *O(n)* because the algorithm grows in proportion to its input *n*:

```
f(int n) {
int i;
for (i = 0; i < n; ++i)
printf("%d", i);
}
```

Similarly, if there was a nested loop, the time would be O(n^{2}).

But what exactly is *O(log n)*? For example, what does it mean to say that the height of a complete binary tree is *O(log n)*?

I do know (maybe not in great detail) what Logarithm is, in the sense that: log_{10} 100 = 2, but I cannot understand how to identify a function with a logarithmic time.

### Accepted Answer

I cannot understand how to identify a function with a log time.

The most common attributes of logarithmic running-time function are that:

- the choice of the next element on which to perform some action is one of several possibilities, and
- only one will need to be chosen.

or

- the elements on which the action is performed are digits of n

This is why, for example, looking up people in a phone book is O(log n). You don't need to check *every* person in the phone book to find the right one; instead, you can simply divide-and-conquer by looking based on where their name is alphabetically, and in every section you only need to explore a subset of each section before you eventually find someone's phone number.

Of course, a bigger phone book will still take you a longer time, but it won't grow as quickly as the proportional increase in the additional size.

We can expand the phone book example to compare other kinds of operations and *their* running time. We will assume our phone book has *businesses* (the "Yellow Pages") which have unique names and *people* (the "White Pages") which may not have unique names. A phone number is assigned to at most one person or business. We will also assume that it takes constant time to flip to a specific page.

Here are the running times of some operations we might perform on the phone book, from fastest to slowest:

**O(1) (in the worst case):**Given the page that a business's name is on and the business name, find the phone number.**O(1) (in the average case):**Given the page that a person's name is on and their name, find the phone number.**O(log n):**Given a person's name, find the phone number by picking a random point about halfway through the part of the book you haven't searched yet, then checking to see whether the person's name is at that point. Then repeat the process about halfway through the part of the book where the person's name lies. (This is a binary search for a person's name.)**O(n):**Find all people whose phone numbers contain the digit "5".**O(n):**Given a phone number, find the person or business with that number.**O(n log n):**There was a mix-up at the printer's office, and our phone book had all its pages inserted in a random order. Fix the ordering so that it's correct by looking at the first name on each page and then putting that page in the appropriate spot in a new, empty phone book.

For the below examples, we're now at the printer's office. Phone books are waiting to be mailed to each resident or business, and there's a sticker on each phone book identifying where it should be mailed to. Every person or business gets one phone book.

**O(n log n):**We want to personalize the phone book, so we're going to find each person or business's name in their designated copy, then circle their name in the book and write a short thank-you note for their patronage.**O(n**A mistake occurred at the office, and every entry in each of the phone books has an extra "0" at the end of the phone number. Take some white-out and remove each zero.^{2}):**O(n · n!):**We're ready to load the phonebooks onto the shipping dock. Unfortunately, the robot that was supposed to load the books has gone haywire: it's putting the books onto the truck in a random order! Even worse, it loads all the books onto the truck, then checks to see if they're in the right order, and if not, it unloads them and starts over. (This is the dreaded**bogo sort**.)**O(n**You fix the robot so that it's loading things correctly. The next day, one of your co-workers plays a prank on you and wires the loading dock robot to the automated printing systems. Every time the robot goes to load an original book, the factory printer makes a duplicate run of all the phonebooks! Fortunately, the robot's bug-detection systems are sophisticated enough that the robot doesn't try printing even more copies when it encounters a duplicate book for loading, but it still has to load every original and duplicate book that's been printed.^{n}):

Read more... Read less...

`O(log N)`

basically means time goes up linearly while the `n`

goes up exponentially. So if it takes `1`

second to compute `10`

elements, it will take `2`

seconds to compute `100`

elements, `3`

seconds to compute `1000`

elements, and so on.

It is `O(log n)`

when we do divide and conquer type of algorithms e.g binary search. Another example is quick sort where each time we divide the array into two parts and each time it takes `O(N)`

time to find a pivot element. Hence it `N O(log N)`

Many good answers have already been posted to this question, but I believe we really are missing an important one - namely, the illustrated answer.

What does it mean to say that the height of a complete binary tree is O(log n)?

The following drawing depicts a binary tree. Notice how each level contains double the number of nodes compared to the level above (hence *binary*):

Binary search is an example with complexity `O(log n)`

. Let's say that the nodes in the bottom level of the tree in figure 1 represents items in some sorted collection. Binary search is a divide-and-conquer algorithm, and the drawing shows how we will need (at most) 4 comparisons to find the record we are searching for in this 16 item dataset.

Assume we had instead a dataset with 32 elements. Continue the drawing above to find that we will now need 5 comparisons to find what we are searching for, as the tree has only grown one level deeper when we multiplied the amount of data. As a result, the complexity of the algorithm can be described as a logarithmic order.

Plotting `log(n)`

on a plain piece of paper, will result in a graph where the rise of the curve decelerates as `n`

increases:

The explanation below is using the case of a fully *balanced* binary tree to help you understand how we get logarithmic time complexity.

Binary tree is a case where a problem of size n is divided into sub-problem of size n/2 until we reach a problem of size 1:

And that's how you get O(log n) which is the amount of work that needs to be done on the above tree to reach a solution.

A common algorithm with O(log n) time complexity is Binary Search whose recursive relation is T(n/2) + O(1) i.e. at every subsequent level of the tree you divide problem into half and do constant amount of additional work.

**Overview**

Others have given good diagram examples, such as the tree diagrams. I did not see any simple code examples. So in addition to my explanation, I'll provide some algorithms with simple print statements to illustrate the complexity of different algorithm categories.

First, you'll want to have a general idea of Logarithm, which you can get from https://en.wikipedia.org/wiki/Logarithm . Natural science use `e`

and the natural log. Engineering disciples will use log_10 (log base 10) and computer scientists will use log_2 (log base 2) a lot, since computers are binary based. Sometimes you'll see abbreviations of natural log as `ln()`

, engineers normally leave the _10 off and just use `log()`

and log_2 is abbreviated as `lg()`

. All of the types of logarithms grow in a similar fashion, that is why they share the same category of `log(n)`

.

When you look at the code examples below, I recommend looking at O(1), then O(n), then O(n^2). After you are good with those, then look at the others. I've included clean examples as well as variations to demonstrate how subtle changes can still result in the same categorization.

You can think of O(1), O(n), O(logn), etc as classes or categories of growth. Some categories will take more time to do than others. These categories help give us a way of ordering the algorithm performance. Some grown faster as the input n grows. The following table demonstrates said growth numerically. In the table below think of log(n) as the ceiling of log_2.

**Simple Code Examples Of Various Big O Categories:**

**O(1) - Constant Time Examples:**

**Algorithm 1:**

Algorithm 1 prints hello once and it doesn't depend on n, so it will always run in constant time, so it is `O(1)`

.

```
print "hello";
```

**Algorithm 2:**

Algorithm 2 prints hello 3 times, however it does not depend on an input size. Even as n grows, this algorithm will always only print hello 3 times. That being said 3, is a constant, so this algorithm is also `O(1)`

.

```
print "hello";
print "hello";
print "hello";
```

**O(log(n)) - Logarithmic Examples:**

**Algorithm 3 - This acts like "log_2"**

Algorithm 3 demonstrates an algorithm that runs in log_2(n). Notice the post operation of the for loop multiples the current value of i by 2, so `i`

goes from 1 to 2 to 4 to 8 to 16 to 32 ...

```
for(int i = 1; i <= n; i = i * 2)
print "hello";
```

**Algorithm 4 - This acts like "log_3"**

Algorithm 4 demonstrates log_3. Notice `i`

goes from 1 to 3 to 9 to 27...

```
for(int i = 1; i <= n; i = i * 3)
print "hello";
```

**Algorithm 5 - This acts like "log_1.02"**

Algorithm 5 is important, as it helps show that as long as the number is greater than 1 and the result is repeatedly multiplied against itself, that you are looking at a logarithmic algorithm.

```
for(double i = 1; i < n; i = i * 1.02)
print "hello";
```

**O(n) - Linear Time Examples:**

**Algorithm 6**

This algorithm is simple, which prints hello n times.

```
for(int i = 0; i < n; i++)
print "hello";
```

**Algorithm 7**

This algorithm shows a variation, where it will print hello n/2 times. n/2 = 1/2 * n. We ignore the 1/2 constant and see that this algorithm is O(n).

```
for(int i = 0; i < n; i = i + 2)
print "hello";
```

**O(n*log(n)) - nlog(n) Examples:**

**Algorithm 8**

Think of this as a combination of `O(log(n))`

and `O(n)`

. The nesting of the for loops help us obtain the `O(n*log(n))`

```
for(int i = 0; i < n; i++)
for(int j = 1; j < n; j = j * 2)
print "hello";
```

**Algorithm 9**

Algorithm 9 is like algorithm 8, but each of the loops has allowed variations, which still result in the final result being `O(n*log(n))`

```
for(int i = 0; i < n; i = i + 2)
for(int j = 1; j < n; j = j * 3)
print "hello";
```

**O(n^2) - n squared Examples:**

**Algorithm 10**

`O(n^2)`

is obtained easily by nesting standard for loops.

```
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
print "hello";
```

**Algorithm 11**

Like algorithm 10, but with some variations.

```
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j = j + 2)
print "hello";
```

**O(n^3) - n cubed Examples:**

**Algorithm 12**

This is like algorithm 10, but with 3 loops instead of 2.

```
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
for(int k = 0; k < n; k++)
print "hello";
```

**Algorithm 13**

Like algorithm 12, but with some variations that still yield `O(n^3)`

.

```
for(int i = 0; i < n; i++)
for(int j = 0; j < n + 5; j = j + 2)
for(int k = 0; k < n; k = k + 3)
print "hello";
```

**Summary**

The above give several straight forward examples, and variations to help demonstrate what subtle changes can be introduced that really don't change the analysis. Hopefully it gives you enough insight.

If you had a function that takes:

```
1 millisecond to complete if you have 2 elements.
2 milliseconds to complete if you have 4 elements.
3 milliseconds to complete if you have 8 elements.
4 milliseconds to complete if you have 16 elements.
...
n milliseconds to complete if you have 2^n elements.
```

Then it takes log_{2}(n) time. The Big O notation, loosely speaking, means that the relationship only needs to be true for large n, and that constant factors and smaller terms can be ignored.