Object-Oriented Programming in Python Goldwasser and Letscher Chapter 14 Sorting Algorithms Terry Scott University of Northern Colorado 2007 Prentice Hall

Terry Scott University of Northern Colorado 2007 Prentice Hall 2 Introduction: What is Covered in Chapter 14 Customizing use of Python’s sort. Selection Sort. Insertion Sort. Merge Sort. Quicksort. Which algorithm does Python use?

Terry Scott University of Northern Colorado 2007 Prentice Hall 3 Standard Lexicographic Sorting >>> data = ['bread','soda','cheese','milk','pretzels'] >>> data.sort() >>> print data ['bread', 'cheese', 'milk', 'pretzels', 'soda' ]

Terry Scott University of Northern Colorado 2007 Prentice Hall 4 lengthCmp Method #A comparison function for lengths #Return -1, 0, or 1 depending on whether a < b, #a == b, or a > b def lengthCmp(a, b): if len(a) < len(b): return -1 elif len(a) == len(b): return 0 else: return 1

Terry Scott University of Northern Colorado 2007 Prentice Hall 5 Sorting by String Length >>> #can use built in cmp function >>> data=['bread', 'soda', 'cheese', 'milk', 'pretzels'] >>> def lengthCmp(a, b): return cmp(len(a), len(b)) >>> data.sort(lengthCmp) #lengthCmp with no parens >>> print data #is a reference to the function ['soda', 'milk', 'bread', 'cheese', 'pretzels']

Terry Scott University of Northern Colorado 2007 Prentice Hall 6 Sorting Decorated Tuples >>> data=['bread', 'soda', 'cheese', 'milk', 'pretzels'] >>> decorated = [ ] >>> for s in data: decorated.append((len(s),s)) >>> print decorated [(5,'bread'),(4,'soda'),(6, 'cheese'),(4,'milk'),(8,'pretzels')] >>> decorated.sort()

Terry Scott University of Northern Colorado 2007 Prentice Hall 7 Sorting Decorated Tuples (continued) >>> for i in range(len(data)): data[i] = decorated[i][1] >>> print data ['soda', 'milk', 'bread', 'cheese', 'pretzels']

Terry Scott University of Northern Colorado 2007 Prentice Hall 8 Decorator Function #sort function has built-in ability to include #a decorator function def lengthDecorator(s): return len(s) data.sort(key=lengthDecorator) #keyword parameter passing #Of course we could have just done data.sort(key = len)

Terry Scott University of Northern Colorado 2007 Prentice Hall 9 Selection Sort 1.Make one pass through the array and find smallest. 2.Swap element at position 0 with the smallest one that was just found. 3.Repeat steps 1 and 2 with the rest of the list. 4.Number of times to do steps 1 and 2 is number of items minus 1 (n – 1). Obviously once n – 1 items are sorted then the nth one is in place. 5.Order of Algorithm is n 2, where n is the number of items in the list.

Terry Scott University of Northern Colorado 2007 Prentice Hall 10 Selection Sort Code def selectionSort(data): hole = 0; #next index to fill while hole < len(data) – 1: #last item sorted is in place small = hole walk = hole + 1 while walk < len(data): if data[walk] < data[small]: small = walk #new minimum found walk += 1 data[hole], data[small] = data[small], data[hole] hole += 1

Terry Scott University of Northern Colorado 2007 Prentice Hall 11 First Seven Passes of Selection Sort

Terry Scott University of Northern Colorado 2007 Prentice Hall 12 Insertion Sort First item is in correct place in the first 1 items. Place 2 nd item in correct spot in the first 2 items. Place 3 rd item in correct spot in the first 3 items. Continue until all items are sorted. Number of times done is number of items (n). Each pass may move item on average number of items looked at divided by 2. Worst case order is n 2 but if list is nearly ordered then order can be nearly n.

Terry Scott University of Northern Colorado 2007 Prentice Hall 13 Insertion Sort def insertionSort(data): next = 1 #index of next item to insert while next < len(data): value = data[next] #will insert this value in place hole = next while hole > 0 and data[hole-1] > value: data[hole] = data[hole-1] #slide data[hole-1] hole -= 1 #forward and the hole back one data[hole] = value next += 1

Terry Scott University of Northern Colorado 2007 Prentice Hall 14 First Seven Passes of Insertion Sort

Terry Scott University of Northern Colorado 2007 Prentice Hall 15 Merge Sort Divide and Conquer solutions: Solve the problem by dividing into smaller problems and solving the smaller problems. Merge sort is a divide and conquer algorithm. If the list is divided into half and each half is sorted, then the two lists can be merged together to make the entire list sorted. Each half of the list is sorted by dividing it into half, sorting each half, then merging them. Recursively we repeat the previous operation until the list size is 1 and it is obviously sorted. This is merged with another list of size 1 and this continues until the list is finally sorted. To avoid having to sort in place, the list is copied into a temporary spot in memory.

Terry Scott University of Northern Colorado 2007 Prentice Hall 16 Merge Sort Code def merge(data, start, mid, stop, temp): i = start while i= stop: temp[i] = data[i] i += 1 mergedMark = start leftMark = start rightMark = mid

Terry Scott University of Northern Colorado 2007 Prentice Hall 17 Merge Sort Code while mergedMark < stop: if leftMark < mid and (rightMark == stop or temp[leftMark] < temp[rightMark]): data[mergedMark] = temp[leftMark] leftMark += 1 else: data[mergedMark] = temp[rightMark] rightMark += 1 mergedMark += 1

Terry Scott University of Northern Colorado 2007 Prentice Hall 18 Merge Diagram The next slide shows how data would be merged. This data is in the temporary buffer and will be placed back in the previous list. It starts with comparing 2 and 3 which are at the start of the first sorted list and at the start of the second sorted list. 2 would then be copied back to the original list since it is smaller. Then 3 and 9 are compared and 3 would be copied. This continues until the end of both lists is reached.

Terry Scott University of Northern Colorado 2007 Prentice Hall 19 Merge Sort

Terry Scott University of Northern Colorado 2007 Prentice Hall 20 Recursive Merge Sort To perform the steps in the merge sort, first setup a function that has a signature that is easily called by the user. Then just call the previously defined merge sort recursively until the list size is down to one.

Terry Scott University of Northern Colorado 2007 Prentice Hall 21 Recursive Merge Sort Code def mergeSort(data) #it creates temporary spot for data so that it is done once. _mergeSort(data, 0, len(data), [none]*len(data) def _recursiveMergeSort(data, start, stop, tempList): if start < stop – 1: mid = (start – stop)//2 _recursiveMergeSort(data, start, mid, tempList) _recursiveMergeSort(data, mid, stop, tempList) _merge(data, start, mid, stop, tempList) #_merge previously defined – now a local function

Terry Scott University of Northern Colorado 2007 Prentice Hall 22 Merge Sort First line is unsorted list. Second line is after left half is sorted. Third line is after right half is sorted. Fourth line is after the merge has occurred.

Terry Scott University of Northern Colorado 2007 Prentice Hall 23 Merge Sort This is similar to the previous figure but is when sorting occurs on the left half of the list. Merge Sort has order Θ(n log 2 n).

Terry Scott University of Northern Colorado 2007 Prentice Hall 24 Quick Sort Quick sort is another divide and conquer algorithm. Best case it has order Θ(n log 2 n). The same as the merge sort. The worst case is when the data is partitioned and all items are either larger or smaller than the pivot. If this were to occur for every partition then the order would degenerate to: Θ(n 2 ). It has the advantage over merge of not requiring extra space.

Terry Scott University of Northern Colorado 2007 Prentice Hall 25 Quick Sort Algorithm Partition the list into two pieces: smaller values and larger values. To do this pick a pivot item: choose last item in list for pivot item. All items less than the pivot item should be placed at the beginning of the list and those that are larger should be placed at the end of the list.

Terry Scott University of Northern Colorado 2007 Prentice Hall 26 Quick Sort The picture below shows the process part way through the partitioning. The 14 is the pivot item. 9, 10, 2, and 10 are smaller than the pivot and are at the beginning of the list. 20 and 18 are larger and are after the smaller items. The algorithm is now ready to process 17. It is larger and so remains where it is. The 3 needs to be moved up to the smaller items so it will be swapped with the 20. This is shown in more detail on the next slide.

Terry Scott University of Northern Colorado 2007 Prentice Hall 27 Quick Sort

Terry Scott University of Northern Colorado 2007 Prentice Hall 28 Quick Sort (continued)

Terry Scott University of Northern Colorado 2007 Prentice Hall 29 Quick Sort Partitioning Code def _quickPartition(data, start, stop): """partition data[start:stop] values are partitioned around the pivot point""" pivotVal = data[stop – 1] big = unknown = start #initially everything unknown while unknown < stop: if data[unknown] <= pivotVal: data[big], data[unknown]=data[unknown],data[big] big += 1 unknown += 1 return big - 1

Terry Scott University of Northern Colorado 2007 Prentice Hall 30 Quick Sort Recursive Code def _recursiveQuicksort(data, start, stop): if start < stop – 1: pivot = _quickPartition(data, start, stop) _recursiveQuicksort(data, start, pivot) _recursiveQuicksort(data,pivot+1, stop)

Terry Scott University of Northern Colorado 2007 Prentice Hall 31 Quick Sort: Complete Trace First line unsorted data. Second line: after first partition: arrow shows moving of pivot element. Remaining lines show succeeding recursions.

Terry Scott University of Northern Colorado 2007 Prentice Hall 32 Which Algorithm Does Python Use for Sorting? For larger lists it uses a variant of the merge sort that does not require as much extra space as was used in the discussion in this chapter. Once the list is smaller it uses insertion sort.