A report of your research on sorting algorithms supported with intext citations/references (Maximum of 500 words)

By William Read
Following from our Search Algorithm investigation from last week our group started
looking at the different Sorting Algorithms we could implement in order to organize
the tower parts that user collects after defeating particular mobs as well as sort the
rounds that have been completed based off of the number of rounds. In order to
achieve this, we need to be able to sort based of numerical and visual criteria so we
could use some of the following algorithms: Bubble Sort, Merge Sort, and Quick Sort
Algorithms.
The Bubble Sort Algorithm is a very basic sorting algorithm and repeatedly steps
through the list until it is fully sorted comparing two items within the list at time by
comparing the neighboring data within the array and then makes sure that if both
items are not sorted (normally the lower of the values being pushed to the left of
the list) and then swaps them, otherwise it just skips onto the next two values
without swapping. (Bubble Sort, HN Computing) This form of search is very good on small lists
but the sort itself is extremely inefficient, the reason for this is the fact that it
becomes closer to a completed list it progressively involves skips of checks which is
incredibly inefficient. (Bubble Sort, HN Computing)
Next is the Merge Sort Algorithm, this sort is based around splitting up the lists into
its elements and then comparing the items within those elements by checking the
element to the adjacent list next to it until it has sorted and merges all the elements
together. (Merge Sort, Wikipedia) The advantage of using this sort includes the ability to sort
data sequentially, however the disadvantages of this is that it requires twice as
much memory to process the operation when dealing with recursive data.
Finally, we looked into the Quick Sort Algorithm this is done by selecting an initial
pivot point in which to start comparing the data within the list too, then splitting the
list into two smaller lists whose elements are less than or greater than the pivot
element. (Quick Sort, Wikipedia) This process is repeated until the size is less than 1. The
advantage of this sorting algorithm is that it is one of the fastest search algorithms
and is also very efficient in how it processes information. However, it would be very
difficult to implement this algorithm within a coded format. (Quick Sort, Comscigate)
Overall, from all the possible solutions available, we decided to go with the Bubble
Sort algorithm mainly for the visual effects and simplicity of the algorithm. This
would make it plausible to show the physical steps of which the algorithm takes in
order to achieve the final desired outcome.
References:
1. Bubble Sort, Wikipedia, 09/03/2016 - https://en.wikipedia.org/wiki/Bubble_sort
2. Bubble Sort, HN Computing, 09/03/2016 - http://www.sqa.org.uk/elearning/ArrayDS03CD/page_09.htm
3. Merge Sort, Wikipedia, 09/03/2016 - https://en.wikipedia.org/wiki/Merge_sort

4. Merge Sort, Teach ICT, 09/03/2016 - http://www.teachict.com/as_as_computing/ocr/H447/F453/3_3_5/data_structures/miniweb_sear

ch/pg8.htm
5. Quick Sort, Wikipedia, 09/03/2016 - https://en.wikipedia.org/wiki/Quicksort
6. Quick Sort, Comscigate, 09/03/2016 http://www.comscigate.com/tutorial/KjellStyle/RakshaVasudevan/Page_8.html