**Big O notation** describes the performance or complexity of an algorithm.

**O(1)** – Constant time complexity – describes an algorithm (a one-line statement code) that will always execute in the same time (or space) regardless of the size of the input data set. An example is accessing a value of an array.

var arr = [ 1,2,3,4,5];
arr[2]; // => 3

**O(N)** – Linear time complexity – describes an algorithm (usually a loop) whose performance will grow linearly and in direct proportion to the size of the input data set. For example, if the array has 10 items, we have to print 10 times. If it has 1,000 items, we have to print 1,000 times.

**//if we used for loop to print out the values of the arrays**

for (var i = 0; i < **array**.length; i++) {
console.log(**array[i]**);
}

**O(log N) – **Logarithmic time complexity –** **describes an algorithm where have a large set of data and you halve the dataset at each iteration until you get the result that you’re looking for. An example of this is finding a word in a dictionary (binary search). Sorting a deck of cards (merge sort) would be O(N log N).

Other examples:

Example 1:
for (var i = 1; i < n; **i = i * 2**)
console.log(i);
}

Example 2:
for (i = n; i >= 1; **i = i/2**)
console.log(i);
}

**O(N**^{2}) – Quadratic time complexity – represents an algorithm whose performance is directly proportional to the square of the size of the input data set. This is common with algorithms that involve nested iterations over the data set. Deeper nested iterations will result in O(N^{3}), O(N^{4}) etc. Examples include checking for duplicates in a deck of cards, bubble sort, selection sort, or insertion sort.

for(var i = 0; i < length; i++) { // **has O(n) time complexity**
for(var j = 0; j < length; j++) { // **has O(n^2) time complexity
// More loops?**
}
}

**O(2**^{N}) – Exponential time complexity – denotes an algorithm whose growth doubles with each addition to the input data set. An example of an O(2^{N}) function is the recursive calculation of Fibonacci numbers. Another example is trying to break a password by testing every possible combination (assuming numerical password of length N).

**Amortized time: **

If you do an operation say a million times, you don’t really care about the worst-case or the best-case of that operation – what you care about is how much time is taken in total when you repeat the operation a million times.

So it doesn’t matter if the operation is very slow once in a while, as long as “once in a while” is rare enough for the slowness to be diluted away (that the cost is “amortized”). Essentially amortised time means “**average time taken per operation, if you do many operations**“.

Source: stackoverflow

**Space complexity: **

Sometimes we want to optimize for using less memory instead of (or in addition to) using less time. Talking about memory cost (or “space complexity”) is very similar to talking about time cost and we also use the Big O notation.

Big O Cheatsheet.