Algorithms and OOD (CSC 207 2014S) : EBoards

# CSC207.01 2014S, Class 27: Merge Sort

Overview

• Preliminaries.
• Admin.
• Questions.
• Lower bounds on sorting.
• Divide and conquer algorithms.
• An introduction to merge sort.
• Analyzing merge sort.

## Preliminaries

### Upcoming work

• Homework 5 due tonight!
• You can send email during class and I'll respond as quickly as I can.
• That should give you an opoportunity to get some cyclic feedback.
• Today's lab writeup: Invariants for merge (part of Exercise 2a)
• You can draw pictures on the computer
• You can draw pictures on paper
• You can write things a bit more mathematically
• Reading for Friday: Quicksort

### Admin

• Continue to have fun with Earnest!
• KS is the note taker today.
• Earnest is happy to answer questions about Skip Lists, whether he knows it or not.
• I'll also try to be on email, and you can collaborate on sending me messages.
• Extra credit:
• Convocation, noon, today.
• Presentations on Grinnell institutional image, noon on Thursday or Friday.
• Other things you should do (warning! tickets go quickly)
• Neverland players.
• Balancing acts.

## Sorting Algorithms

• What makes a sorting algorithm stable?
• If a is before b in the original array and a = b, then a is before b is the final array
• Is selection sort stable?
• It depends on `indexOfSmallest`
• If we update `small` when `order.compare(vals[i], vals[small]) < 0` then it is stable
• If we update `small` when `order.compare(vals[i], vals[small]) <= 0` then it is NOT stable

## Merge Sort

• Take an array, divide it in half and keep dividing it in half until we have only pairs. Sort the pairs and go back up the tree, merging the parts as you go.
• To merge check which of the first two elements (of the parts you are merging) comes first until one part has no remaining elements

Break down the array:

``````7 3 2 8 1 5 6 4

7 3 2 8   1 5 6 4

7 3   2 8   1 5   6 4
``````

Build it back up:

``````3 7   2 8   1 5   4 6

2 3 7 8   1 4 5 6

1 2 3 4 5 6 7 8
``````

[Sam notes that recursion doesn't quite work this way. We do the left subarray completely before we do the right subarray.]

## Skip Lists

• Functions that might be useful:
• `contains`
• `add`
• Consider a singly linked list with a height cap
• When you add an element, you need to make it point to what all the preceding pointers were pointing to before it was inserted. Then make the preceding pointers point to your new element.
• `remove`
• `findPlace`
• Skip list element object (SkipLO)
• Useful fields:
• `int level;` [Sam notes that you can get this with `next.length`.]
• `String value;`
• `SkipLO[] nexts;`
• Constructor:
• `Constructor (int l, String str)` [Sam notes there's an interesting design decision: Does the list class deside on the level, or does the node constructor decide upon the level?]
• `level = l;` [If the node computes the level, this would be `computeLevel()`]
• `value = str;`
• `nexts = new SkipLO[level];`
• Get fields
• obj.level
• obj.value
• obj.next[l]
• You need to keep track of what comes before the element you are interested in because they're singly linked and you can't just go back.

## Do the lab!

Copyright (c) 2013-14 Samuel A. Rebelsky.

This work is licensed under a Creative Commons Attribution 3.0 Unported License. To view a copy of this license, visit `http://creativecommons.org/licenses/by/3.0/` or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San Francisco, California, 94105, USA.