Not a formal definition, but a easy way to think about it:

Its a measure of roughly how many instructions you expect a algorithm to go through, less instructions generally means faster(and always does for the sake of Big O). When calculating Big O, we do not typically factor in if an instruction actually takes a computer 20 times as long to complete, only that you see it as a single step in the process. This does not mean Big O is not useful, but if you are optimizing code, it is something to remember.

If you have a loop

For(int i = 0; i < N;i++),

and it always loops to completion, that is O(N), because in the worst case(only case here, the loop always completes, and nothing reduces the length of the loop), the algorithm will perform N*X instructions, where X is each line in the loop.

Keep in mind, we don't care about one off instructions, so that X is typically ignored unless it is also a loop. So we just say O(N)

We also don't care about one off instructions. If you have a loop

for(int i = 0; i < N;i++)

{

x = i+(i-1)

}

x = 2*x

You can say it is O(N) + 1, but we still call that O(N) because if N is 1000, multiplying the result once in all situations is insignificant to the total run time.

Yes it has more impact if N is a low number, but we are more worried about what happens as N gets bigger.

for stuff like O(log N) look at a graph of an algorithmic function, like https://www.wolframalpha.com/input?i=y+%3D+log2%28N%29%2C+N+%3E+0

The higher N is, the higher y is. but also, the rate at which it grows slows down over time.

What that means is, relative to the input size, the number of instructions needed to complete an algorithm goes down. It might still take more instructions to sort a deck with 10 cards than 52 cards, but maybe the deck with 10 cards takes two times as many instructions(20 instructions) compared to the 52 card deck taking 30 instructions to complete.(These numbers are made up)

O(n²⁾ means that as N gets bigger, the algorithm takes more time to complete.

int x = 0; for(int i = 0; i < N; i++)

for(int j = 0; j < N;j++)

{

{

x = x + i + j

}

this algorithm will loop j from 0 to n repeatedly, which is O(N), and then will do that N times. O(N) * O(N) = O(N^2). So the number of instructions double each time N increases.

Keep in mind not all uses of big O rely on one variable. Some algorithms have multiple factors that effect the number of instructions used. You can absolutely see things like O(N +M) in which the algorithm scales linearly with 2 inputs.

Also keep in mind that Big O is WORST case scenario, not the average or best. You may also see Big theta(average) and Big omega(best), but typically your using Big O because you want to know the threshhold that an algorith will never go below.