Analysis of Linear Search

Analysis of Linear Search

Linear Search, as the name implies is a searching algorithm which obtains its result by traversing a list of data items in a linear fashion. It will start at the beginning of a list, and mosey on through until the desired element is found, or in some cases is not found. The aspect of Linear Search which makes it inefficient in this respect is that if the element is not in the list it will have to go through the entire list. As you can imagine this can be quite cumbersome for lists of very large magnitude, keep this in mind as you contemplate how and where to implement this algorithm. Of course conversely the best case for this would be that the element one is searching for is the first element of the list, this will be elaborated more so in the ―Analysis & Conclusion‖ section of this tutorial.

Linear Search Steps:

Step 1 - Does the item match the value I’m looking for?

Step 2 - If it does match return, you’ve found your item! Step 3 - If it does not match advance and repeat the process.

Step 4 - Reached the end of the list and still no value found? Well obviously the item is not in the list! Return -1 to signify you have not found your value.

As always, visual representations are a bit more clear and concise so let me present one for you now. Imagine you have a random assortment of integers for this list:

Legend:

-The key is blue

-The current item is green. -Checked items are red

Ok so here is our number set, my lucky number happens to be 7 so let‘s put this value as the key, or the value in which we hope Linear Search can find. Notice the indexes of the array above each of the elements, meaning this has a size or length of 5. I digress let us look at the first term at position 0. The value held here 3, which is not equal to 7. We move on.

--0 1 2 3 4 5 [ 3 2 5 1 7 0 ]

So we hit position 0, on to position 1. The value 2 is held here. Hmm still not equal to 7. We march on.

--0 1 2 3 4 5 [ 3 2 5 1 7 0 ]

Position 2 is next on the list, and sadly holds a 5, still not the number we‘re looking for. Again we move up one.

--0 1 2 3 4 5 [ 3 2 5 1 7 0 ]

Now at index 3 we have value 1. Nice try but no cigar let‘s move forward yet again. --0 1 2 3 4 5 [ 3 2 5 1 7 0 ]

Ah Ha! Position 4 is the one that has been harboring 7, we return the position in the array which holds 7 and exit.

--0 1 2 3 4 5 [ 3 2 5 1 7 0 ]

As you can tell, the algorithm may work find for sets of small data but for incredibly large data sets I don‘t think I have to convince you any further that this would just be down right inefficient to use for exceeding large sets. Again keep in mind that Linear Search has its place and it is not meant to be perfect but to mold to your situation that requires a search.

Also note that if we were looking for lets say 4 in our list above (4 is not in the set) we would traverse through the entire list and exit empty handed. I intend to do a tutorial on Binary Search which will give a much better solution to what we have here however it requires a special case.

//linearSearch Function

int linearSearch(int data[], int length, int val) {

for (int i = 0; i <= length; i++) { if (val == data[i]) {

return i; }//end if

}//end for

return -1; //Value was not in the list }//end linearSearch Function

Analysis & Conclusion

As we have seen throughout this tutorial that Linear Search is certainly not the absolute best method for searching but do not let this taint your view on the algorithm itself. People are always attempting to better versions of current algorithms in an effort to make existing ones more efficient. Not to mention that Linear Search as shown has its place and at the very least is a great beginner‘s introduction into the world of searching algorithms. With this is mind we progress to the asymptotic analysis of the Linear Search:

Worst Case:

The worse case for Linear Search is achieved if the element to be found is not in the list at all. This would entail the algorithm to traverse the entire list and return nothing. Thus the worst case running time is:

O(N).

Average Case:

The average case is in short revealed by insinuating that the average element would be somewhere in the middle of the list or N/2. This does not change since we are dividing by a constant factor here, so again the average case would be:

O(N).

Best Case:

The best case can be a reached if the element to be found is the first one in the list. This would not have to do any traversing spare the first one giving this a constant time complexity or:

O(1).