More on algorithms
In this lesson, we will be looking at an overview of different common categories of problems faced in computer science, and a few of their solutions algorithms.
Introduction
In the previous project, we looked at how to solve a very simple problem like generating the fibonacci sequence both recursively and iteratively and explored their strengths and weaknesses. We then looked at the Merge Sort
algorithm, and worked on implementing it recursively at the very least. If you attempted to implement it iteratively; you may well have found the approach to implementing it vastly different to the recursive counter part.
In this lesson, we will be looking at an overview of different common categories of problems faced in computer science, and a few of their solutions algorithms. It should be noted that these algorithms approach arrays specifically; and not other data structures that we shall look at in future.
Learning outcomes
Look through these now and then use them to test yourself after doing the assignment:
Name three different sorting algorithms
Name two different types of search algorithm, with an example of each
Sorting it out
More often than not, regardless of whether you're doing Web Development or some other kind of software engineering; you will most likely be dealing with information of some sort and may need to store it. You could take the time to store that piece of data into the correct place to maintain a sorted data set; or you can just insert said data in and bring order to the chaos later! Arranging data in some sequential order is the task that sorting algorithms should solve.
The problem - we have an unsorted away, and we need to have it in sequential order.
Merge Sort
Thankfully, you've already looked at Merge sort
in your previous project. With this algorithm, you split the original algorithm into two chunks, and then merge sort the individual chunks, further breaking down those chunks and building them back up in sorted order. This is a Divide and Conquer
algorithm. This is an algorithm that commonly sees use built into some languages.
Quicksort
Quicksort is another Divide and Conquer
algorithm, which finds a pivot some point in the array, and partitions the array into two sub arrays, depending on whether the element's value is comparatively less than or greater than the pivot. This process is repeated on both sub arrays, and the sub arrays are joined with the pivot to return the sorted array.
Insertion Sort
For heavily unsorted data sets, this method of sorting will go through your data set a large number of times, which is why this is an inefficient algorithm for such sets. For almost completed sets, however; fewer comparisons need to be made, and even fewer swaps, which gives Insertion Sort
an advantage in these specific situations. If you were to put data into a sorted array into it's correct position, you're essentially performing an Insertion Sort
.
Bubble Sort
This algorithm is mainly used as an education exercise for doing things with arrays and basic sorting.
Bogosort
Searching
So we have a data set, be it sorted or not. At some point, we're going to need to have a look through it to find some value if such a value actually exists. This problem is generally approached by algorithms falling into one of two categories:
Sequential Search
As the name suggests, this involves starting from one end of your data set, and through through each data point sequentially until you find the correct one if it exists. Linear Search
is an example of this. You will have most certainly used this method when iterating through your arrays in previous projects. The biggest advantage with this paradigm is that it can reliably handle unsorted data sets.
Interval Search
Unlike it's sequential cousin, interval search involves starting at some data point, usually the middle of the array; and then shifting it's focus to a different focus point depending on whether the desired value is less than, or greater than, the current value being looked at. This can make the searching process considerably faster than sequential searches, with the downside of requiring the dataset to be ordered beforehand.
Binary Search
The classic example of an Interval Search
, Binary Search
starts off at the mid point of a dataset. If the mid point does not have the value the algorithm wants, the search moves to the point between the mid point and the beginning/end of the array, depending on whether the wanted value is less than or greater than the currently looked at value. This process is then repeated in the sub section of the array from beginning to mid point or mid point to end of the array. Rinse and repeat until the value is found or no value is found!
Conclusion and remarks
In this lesson, we have gone into some detail about searching and sorting data arrays and ways of going about it, and also had a good laugh at Bogosort! We understand the strengths and weaknesses, on a high level, of some algorithms; as well as different approaches to this commonly faced problems!
It should be stressed again, like in previous lessons; that most languages will have a well written, highly efficient search/sort algorithm(s) built into the language for you to use. These are written by people with a wealth of experience. As much as you should learn how to write these algorithms as an educational exercise or curiosity; you shouldn't "reinvent the wheel" in the real world unless you have a good, well researched reason to. Or if your boss demands it!
Assignment
Do some reading on the seven algorithms mentioned above! Wikipedia is a fairly solid guide on these.
See if you can write the pseudo-code (or language code!) for these algorithms as practice! Try them on different data sets to figure out what works and what doesn't work so well!
Look around the internet to see what algorithm your language uses to solve these problems. Sorting in particular!
Last updated