1. Sorting • Begin by filling an array with random numbers: import numpy as np np.random.seed(1012) DATASIZE = 1000 MAX_VALUE = 10000000 data = np.random.randint(0, MAX_VALUE, size=DATASIZE) • Write a function that is passed a numpy array. The function should walk through the array element-by-element, comparing the current element to the next element. Swap if the next is smaller than the current – sorting these two elements. • Write a second function that calls the above function n times, where n is the number of elements (size) of the array. Pass the same numpy array each time.

1. Sorting
• Begin by filling an array with random numbers:
import numpy as np
np.random.seed(1012)
DATASIZE = 1000
MAX_VALUE = 10000000
data = np.random.randint(0, MAX_VALUE, size=DATASIZE)
• Write a function that is passed a numpy array. The function should walk
through the array element-by-element, comparing the current element to
the next element. Swap if the next is smaller than the current – sorting
these two elements.
• Write a second function that calls the above function n times, where n is
the number of elements (size) of the array. Pass the same numpy array
each time.

 

2. Bubble Sort
• The sort from part 1 can be improved. If the data passed to be sorted is
already sorted, it still performs all of the work, as if the array was not
sorted.
Make two improvements:
• Change the first function (the one that does the comparisons), so that it returns a
boolean that states whether the array is sorted. Make use of that boolean to stop
calling the first function if the array is sorted.
• Consider what happens when the first function is called. For randomly distributed
data, some comparisons will lead to swaps, and others won’t. But, the largest
number will certainly “float” to the end of the array. Future calls of the first
function will not move that largest number, and we could therefore end the
comparisons done in future calls without examining the last position in the array.
• Modify the first function further. Add a parameter that specifies the index at
which the comparisons & swaps should stop. Modify the second function so
that one fewer element is examined each time the first function is called.

 

3. Selection Sort
• The idea in a selection sort is that you locate the largest item out of a set of
unsorted items, and move it into position at the end of the unsorted items. A
sorted region grows one item at a time, while an unsorted region shrinks.
• As done in Part 1, fill an array with random numbers.
• Write a function that locates the largest element in the portion of the array
beginning at the start of the array, up to a given index, and swaps the largest
item with the item at the given index.
• E.g. If searching a[0] to a[7] locates the largest item at a[4], a[4] and a[7] would be
swapped.
• Write a second function that calls the first function repeatedly, until the entire
array is sorted. (Each time the first function is called, it will search one fewer
element)

 

4. Insertion Sort
• The idea with an insertion sort is that a sorted region grows one item at a
time, by inserting an item into its correct position within the sorted region.
• As done in Part 1, fill an array with random numbers.
• Write a function that inserts an item into a sorted region of an array. Pass
the function the index of the item to be inserted (i.e. the index of the first
item in the unsorted region). Insert that item by shifting items over one
position, until you have found the correct location to insert the item.
• E.g. if given a = [2 5 8 9 6 3 7] and the index 4, a[4] should be inserted into the
sorted portion, giving [2 5 6 8 9 3 7]
• Write a second function that calls the first function repeatedly, until the
entire array is sorted. (Each time the first function is called, it will insert an
item into a larger sorted region.)