# Using Big-O notation to Determine the Efficiency of an Algorithm By Alex Allain
The ability to analyze a piece of code or an algorithm and understand its efficiency is vital for understanding computer science as well as to simply make sure that your programs run quickly without boring your user.

One approach to determining the big-O value (an algorithm's order) is to start out assuming an order of O(1), an algorithm that doesn't do anything and immediately terminates no matter what the input. Then, find the section of code that you expect to have the highest order. From there, work out the algorithmic efficiency from the outside in -- figure out the efficiency of the outer loop or recursive portion of the code, then find the efficiency of the inner code; the total efficiency is the efficiency of each layer of code multiplied together.

For instance, to compute the efficiency of a simple selection sort
```	for(int x=0; x<n; x++)
{
int min = x;
for(int y=x; y<n; y++)
{
if(array[y]<array[min])
min=y;
}
int temp = array[x];
array[x] = array[min];
array[min] = temp;
}
```
We compute that the order of the outer loop (for(int x = 0; ..)) is O(n); then, we compute that the order of the inner loop is roughly O(n). Note that even though its efficiency varies based on the value of x, the average efficiency is n/2, and we ignore the constant, so it's O(n). After multiplying together the order of the outer and the inner loop, we have O(n^2).

In order to use this approach effectively, you have to be able to deduce the order of the various steps of the algorithm. And you won't always have a piece of code to look at; sometimes you may want to just discuss a concept and determine its order. Some efficiencies are more important than others in computer science, and on the next page, you'll see a list of the most important and useful orders of efficiency, along with examples of algorithms having that efficiency.

Part 3: Examples of various orders and algorithms