Sorting algorithms: Bubble, Selection, and Tree Sort

Transcription

1 Courses 5LN446 & 5LN715 Sorting algorithms: Bubble, Selection, and Tree Sort Mats Dahllöf Dept of Linguistics and Philology October / 29

2 Today Sorting sequences of values (important in many contexts) Sorting algorithms sorting can be done in many ways. Today, we ll look at: Bubble Sort Selection Sort Tree Sort i.e. more about tree structures and object-oriented design 2 / 29

3 Sorting To have collections sorted is important in many contexts, both for humans and for machines. Search can be performed more efficiently. There are many algorithms for sorting (which is the most famous algorithmic problem). Python lists have a built-in sort() method that modifies the list in-place. (Comparison methods must be defined for classes, e.g. lt.) We look at sorting as an algorithm and programming exercise. 3 / 29

4 Check that list is sorted def checksorted(alist): """Check that list is sorted""" for p in range(0, len(alist)-1): if alist[p] > alist[p+1]: return True return False What about duplicate values? < and > also for strings (alphabetical order). Note: alphabetical order is not that simple (different languages, different conventions). 4 / 29

5 Using comparison by < instead of >? def checksorted(alist): """Check WHAT?""" for p in range(0, len(alist)-1): if alist[p] < alist[p+1]: return False return True 5 / 29

6 Using comparison by < instead of >? def checksorted(alist): """Check that list is sorted in descending order""" for p in range(0, len(alist)-1): if alist[p] < alist[p+1]: return False return True Descending order: larger smaller. Ascending order: smaller larger (default/common). 6 / 29

7 Swapping the values of two variables Swapping by means of tuple assignment a,b=b,a. (Python style.) Other solution (necessary in most languages): temp = a a = b b = temp Note: Doing this won t achieve swapping: a = b # a gets b's value b = a # will have no effect 7 / 29

8 A simple algorithm: Bubble Sort Topmost loop: Put the largest element at the last position, then the second largest before that, etc. (Sink sort rather.) So, the right part of the list is sorted and grows by one step for each topmost iteration. Embedded loop: check each adjacent pair of values in the unsorted left part of the list and swap them if they are in the wrong order. Do this from left to right. Finally all of the list is sorted. 8 / 29

9 Bubble Sort (or rather Sink) def bubblesort(li): for p in range(0, len(li)-1): for c in range(1, len(li)-p): if li[c-1] > li[c]: li[c-1],li[c]=li[c],li[c-1] In-place algorithm: operates on the input data structure only. The same idea will work with a leftmost-finished-first scheme. (Exercise!) 9 / 29

10 Bubble Sort (another modification) def bubblesortvar(li): for p in range(0, len(li)-1): for c in range(0, len(li)-p-1): if li[c] > li[c+1]: li[c],li[c+1]=li[c+1],li[c] We can shift ranges and indexes and get the same behaviour. 10 / 29

11 Bubble Sort feedbacking version def bubblesort(li): for p in range(0, len(li)-1): print('embedded loop, range(', 1,',',len(li)-p,')') for c in range(1, len(li)-p): if li[c-1] > li[c]: li[c-1],li[c]=li[c],li[c-1] print('sw:', li[c-1], '/', li[c], li) Good way of analysing a procedure make it print reports of what is happening. 11 / 29

12 Bubble Sort Call: bubblesort(['y','x','b','m','a']) Embedded loop, range( 1, 5 ) Sw: x / y ['x', 'y', 'b', 'm', 'a'] Sw: b / y ['x', 'b', 'y', 'm', 'a'] Sw: m / y ['x', 'b', 'm', 'y', 'a'] Sw: a / y ['x', 'b', 'm', 'a', 'y'] Embedded loop, range( 1, 4 ) Sw: b / x ['b', 'x', 'm', 'a', 'y'] Sw: m / x ['b', 'm', 'x', 'a', 'y'] Sw: a / x ['b', 'm', 'a', 'x', 'y'] Embedded loop, range( 1, 3 ) Sw: a / m ['b', 'a', 'm', 'x', 'y'] Embedded loop, range( 1, 2 ) Sw: a / b ['a', 'b', 'm', 'x', 'y'] 12 / 29

13 A simple algorithm: Selection Sort Topmost loop: Put the smallest element at position 0, then the second smallest at position 1, etc. So, the left part of the list is sorted and grows by one step for each topmost iteration. Embedded loop: find the smallest element in the unsorted right part of the list and put it first (thus making the sorted left part longer and the unsorted right part shorter). Finally all of the list is sorted. 13 / 29

14 Selection Sort def selectionsort(li): # version 1 for p in range(0, len(li)-1): sv = li[p] # smallest val si = p # smallest val index for c in range(p+1, len(li)): if sv > li[c]: sv = li[c] si = c li[si],li[p]=li[p],li[si] 14 / 29

15 Selection Sort more compact code def selectionsort(li): # version 2 for p in range(0, len(li)-1): for c in range(p+1, len(li)): if li[p] > li[c]: li[p],li[c]=li[c],li[p] No help variables more swaps in the list. Strictly in-place operation. 15 / 29

16 Selection Sort feedbacking def selectionsort(li): for p in range(0, len(li)-1): print('embedded loop, range(', p+1,',',len(li),')') for c in range(p+1, len(li)): if li[p] > li[c]: li[p],li[c]=li[c],li[p] print('sw:', li[p], '/', li[c], li) Focus position, p, just before the embedded loop range. 16 / 29

17 Selection Sort Call: selectionsort(['y','x','b','m','a']) Embedded loop, range( 1, 5 ) Sw: x / y ['x', 'y', 'b', 'm', 'a'] Sw: b / x ['b', 'y', 'x', 'm', 'a'] Sw: a / b ['a', 'y', 'x', 'm', 'b'] Embedded loop, range( 2, 5 ) Sw: x / y ['a', 'x', 'y', 'm', 'b'] Sw: m / x ['a', 'm', 'y', 'x', 'b'] Sw: b / m ['a', 'b', 'y', 'x', 'm'] Embedded loop, range( 3, 5 ) Sw: x / y ['a', 'b', 'x', 'y', 'm'] Sw: m / x ['a', 'b', 'm', 'y', 'x'] Embedded loop, range( 4, 5 ) Sw: x / y ['a', 'b', 'm', 'x', 'y'] 17 / 29

18 Selection Sort complexity List with n elements: (Bubble Sort same.) Topmost loop: n 1 iterations, for p in 0, 1, 2,..., n 2 Embedded loop: n p 1 comparisons. I.e. f (n) = (n 1) comparisons f (n) = n2 n 2 (equivalent) E.g. f (8) = 28 So-called triangular numbers. Quadratic complexity the n 2 term dominates. 18 / 29

19 Time measuring experiment 19 / 29

20 Tree structure last time S NP VP det adj n v NP The brown dogs chase det n the cats Tree structures often used for syntax in LT and linguistics. 20 / 29

21 Tree structure last time Two attributes: symbol for 'S', 'NP', etc. subtrees a list for the subtrees. Special case: empty list (on so-called leaves). (Compare next in PS linked list Node.) 21 / 29

22 Trees for sorting and searching Smaller to the left Larger to the right Binary (two-way) search tree. At most two subtrees. If there us just one, we must know if it is the left or right one. 22 / 29

23 New values can be inserted (e.g. 14) None 14 None None None None One left and one right subtree, possibly absent (None). 23 / 29

24 And 12, e.g. Now omitting double None values in the picture None None 24 / 29

25 And 19, e.g None None 12 None 25 / 29

26 Same values different structures None None None None None None 26 / 29

27 Binary search trees class BSNode: def init (self,val): self.value = val self.left = None self.right = None Structure depends on order of insertion. We want short paths balanced trees. Retrieval in sorted order simple. Gives us Tree Sort a not in-place algorithm. Deletion of values: somewhat tricky procedure. 27 / 29

28 Time measuring with my Tree Sort 28 / 29

29 Trees and sorting More in the assignments! Collect values in a certain order Measure the depth of a tree Recursive programming natural matches the structures Non-recursive solutions interesting for comparison 29 / 29