代写Computer Programming、代做CS/python、代做sorting algorithms、java/c++设计代做

日期：2018-10-29 11:45

Computer Programming 2 Assignment 3

Assignment 3: Sort Wars

Core Questions (5 marks each)

Task

If quicksort is so quick, why bother with anything else? If bubble sort is so bad, why even mention

it? For that matter, why are there so many sorting algorithms?

Your mission (should you choose to accept it) is to investigate these and other questions in relation

to the algorithms selection sort, insertion sort, merge sort, and quicksort.

1. Explain each of the algorithms in a way that would be understandable to an intelligent lay

person. You should not use any code (or even pseudo code) in your explanation, but you will

probably need to use general concepts such as "compare" and "swap", and you'll certainly

need to use procedural words such as "if" and "repeat".

You might find it helpful to consider an algorithm as if it were a game for which you need to

define the rules. For example, here's how you could describe the bubble sort algorithm as if it

was a solitaire game played with a deck of cards that contain the values to process.

2. Write a set of guidelines for helping someone decide which sort algorithm would be most

appropriate for a particular situation. Include in your guidelines a description of the

advantages and disadvantages of each algorithm, together with an indication as to why those

characteristics apply. Your goal is to provide enough information so that someone not familiar

with the details of each algorithm would be able to decide which algorithm is right for them.

For example, if someone was considering using counting sort, then the following brief

information could help decide if it was appropriate.

Flinders University / College of Science and Engineering 1

Bubble Trouble

The playing area consists of several regions: foundation, tableau, stock, and discard.

Initially, all cards are in the stock.

Play consists of a number of rounds. To begin a round, place the top card of the

stock face up in the tableau, then turn over the next card. If the stock card is smaller

that the tableau card, place it face down on the discard pile; otherwise, place the

tableau card on the discard pile and the stock card in the tableau. Play the remaining

stock cards in the same way, then move the final tableau card (which will be the

largest of the stock cards) to the foundation and use the discard pile as the new stock.

This completes one round.

Continue to play rounds until the stock is exhausted. The cards in the foundation

will now be sorted with the smallest card on top.

Computer Programming 2 Assignment 3

Extension Questions (5 marks each)

Background

In this section, you'll need to be able to measure the speed of execution of parts of your code. On a

Unix system, you can measure how much time a section of code takes by calling the system

function getrusage before and after that section. The function returns information about various

aspects of resource usage, including the amount of system time (time taken by system routines that

you call) and the amount of user time (time taken by your own code). Note that this is process time,

not "wall-clock" time, so it's an accurate measure even if the system is busy executing other

people's code as well. Consult the man page for getrusage if you need more information.

#include <sys/resource.h>

int main() {

struct rusage before, after; // for recording usage stats

// prepare the data

getrusage(RUSAGE_SELF, &before);

// execute the code you want to time

getrusage(RUSAGE_SELF, &after);

int secs = after.ru_utime.tv_sec - before.ru_utime.tv_sec;

int usecs = after.ru_utime.tv_usec - before.ru_utime.tv_usec;

cout << secs * 1000000 + usecs << endl; // in microseconds

}

Algorithm Counting Sort

Description ? Count the number of times each different value appears, then

overwrite the values in lowest-to-highest order, with each value

repeated according to the counts.

Advantages Usually faster than any of the comparison-based sorts. Algorithmic

complexity is O(n + k), irrespective of data order, where n is the list

length and k is the number of distinct values that might occur. Typical

case is where k << n, in which case cost is O(n).

Simple to code.

Disadvantages ? Only usable where the values to be sorted can be used to index an

array of value counts, which usually means the values are integers

over a small range. In other words, the algorithm can't be used to sort

common non-integral values such as strings and floats, and it's

inappropriate even for integers if the range of values is large.

Requires an auxiliary array (to store the counts) of size equal to the

number of different possible sort values. If the range of values is

large, the cost of allocating and maintaining this array could be

significant.

When to use If your circumstances allow, it's hard to beat this algorithm. But

because it places very tight restrictions on the nature of the data to

sort, you will often have to choose another approach.

Flinders University / College of Science and Engineering 2

Computer Programming 2 Assignment 3

Task

Practical sort implementations usually combine more than one sorting algorithm, attempting to take

advantage of the best characteristics of each. For example, a straightforward but effective approach

for general-purpose sorting is to use quicksort, but with a switch-over to insertion sort when the size

of the lists that result from the partitioning falls below a threshold value. The structure of the

combined sort would be like this:

sort (...) {

if size is less than threshold {

do an insertion sort

} else { // do a quicksort

partition

recursively sort the first part

recursively sort the second part

}

}

This approach is generally faster that using pure quicksort because insertion sort has a lower

overhead than quicksort and is thus faster, provided the length of the list is small enough. To get the

greatest speedup, the threshold for switching to insertion sort needs to be carefully chosen: too

large, and the greater algorithmic cost of the insertion sort will overwhelm any lower overheads; too

small, and the potential benefits of the combined approach are wasted.

3. Design an experiment to determine the best "cutover" threshold size for the combined

"quicksort-plus-insertion-sort" implementation. You'll need to consider a range of data sizes,

including both random and "worst-case" data sets.

Write a program that could be used to perform the experiment. You'll need to provide the sort

code itself (use your code from prac 5) as well as a suitable main function for testing it (adapt

the main function from prac 5).

Your experimental design should be sufficiently detailed that you could hand the task over to

a tester who is not familiar with sorting algorithms or even with programming. Ideally, the

tester should only need to run the program under specified conditions and record the results.

4. Run your experiment and report on the findings. Your report should include the data you

gather, an analysis of that data, and a clear recommendation as to the best cutover threshold.

Consider how best to present your results. You'll certainly want to tabulate the data, but you

might also find it helpful to plot it as well. Because the actual times will be heavily dependent

on the data size, you might find it useful to normalise the times against the "ideal" time (by

dividing by n log n) before plotting them.

Assessment

Pairing

This assignment must be done individually.

Scoring

Submit written material as PDF reports to the appropriate handins on FLO. The "core" score will be

based on your answers to the 2 "core" questions, and the "extension" score will be based on your

answers to the 2 "extension" questions.

Your answer for each question should be between 300 and 600 words (half to 1 typed page),

excluding code listings (where appropriate), which should be as an appendix in your report. Your

Flinders University / College of Science and Engineering 3

Computer Programming 2 Assignment 3

submission should conform to accepted practices for academic writing. Of course, you must give

appropriate acknowledgement to any material that you use or reference.