reveal.js

# Merge Sort

---

CS 65 // 2021-04-29

## Pro Tip of the Day
- For graphics in your projects, you can use the `Image` class in the same way as other shapes
    ```py
    img = Image(Point(0,0), "pacman.png")
    img.draw(win)
    img.move(5,5))
    ```

# Questions
## ... about anything?

# Selection Sort

## Selection Sort

- **Key idea**:
    + Repeat the following until it is sorted:
    + 
 Look through the collection to find the **smallest**
    + 
 Move that element to the **beginning** of the unsorted region of the list

</div>
<div>

![selection sort animation](https://upload.wikimedia.org/wikipedia/commons/9/94/Selection-Sort-Animation.gif)

</div>
</div>

## Docstring for Sort
```py
def selection_sort(lst):
    """Sorts lst so that its elements are in ascending order

Parameters:
        lst: a list

Returns:
        Nothing; just modifies lst

Preconditions:
        * for all elements x,y in lst,
            x < y is defined

Postconditions:
        * lst is reorganized in increasing order, i.e., 
              lst[i] <= lst[i+1]
          holds for all reasonable values of i
        * no elements are added or removed from lst"""
```

# Implementation of Selection Sort
- [selection_sort.py](/teaching/2021s/cs65/assets/code/selection_sort.py)

## Selection Sort Visualization
<iframe width="840" height="473" src="https://www.youtube.com/embed/kPRA0W1kECg?mute=1" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

# Merge Sort

## Divide and Conquer Algorithms

![split big problem into subproblems](/teaching/2021s/cs65/assets/images/divide-and-conquer.png)

## Merge Sort

- **Key idea:**
    + Divide the list into two halves
    + Recursively sort each independently
    + Merge the two sorted lists together

![merge sort animation](https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif)

# Implementation of Merge Sort
- [merge_sort.py](/teaching/2021s/cs65/assets/code/merge_sort.py)

## Visualization of Merge Sort

# Measuring Efficiency

---

XKCD #1445

## Various Sorting Algorithms

## Analyzing Efficiency
- What do we mean when we say that an algorithm is **efficient**?
- 
 How can we **measure** the efficiency of an algorithm?

## Analyzing Efficiency
- Two most common metrics for efficiency:
- 
 **Time Complexity**
    + How much "time" it takes for an algorithm to complete
    + Usually measured in "number of basic steps" the algorithm takes
- 
 **Space Complexity**
    + How much "memory" the algorithm uses while it is working

## Efficiency and Input Size
- The number of steps some operations take on a list do not depend on the size of the list. These are called **constant time operations**
- Others take a number of steps proportional to the length of the list. These are called **linear time operations**

## Efficiency and Input Size
- What **constant time** operations have we seen?
- 
 What **linear time** operations have we seen?

## Selection Sort Complexity
- How many comparisons does selection sort take in terms of `n = len(lst)`?
```py
def selection_sort(lst):
    for i in range(len(lst)):
        s_index = find_smallest(lst, i)
        swap(lst, i, s_index)
```
```py
def find_smallest(lst, i):
    smallest_so_far = i
    for j in range(i, len(lst)):
        if lst[j] < lst[smallest_so_far]:
            smallest_so_far = j
    return smallest_so_far
```

## Big Oh Notation
- Counting the number of steps *exactly* is cumbersome
- 
 Big Oh notation allows us to specify time complexity neatly by ignoring all aspects except the fastest part
- 
 **Constant Time**: $O(1)$
- 
 **Logarithmic Time**: $O(\log(n))$
- 
 **Linear Time**: $O(n)$
- 
 **Quadratic Time**: $O(n^2)$
- 
 **Exponential Time**: $O(2^n)$

# Merge Sort Complexity

## Time Complexity Cases
- The **worst** case, **average** case, and **best** case for an algorithm may be different
- 
 For example, with insertion sort:
    + 
 Best case is **linear time**: $O(n)$
    + 
 Worst case is **quadratic time**: $O(n^2)$
    + 
 Average case is **quadratic time**:   $O(n^2)$
- 
 For selection sort, all cases are the same: $O(n^2)$
- 
 For merge sort, all cases are the same: $O(n\cdot\log(n))$

# Fibonacci Sequence

## Fibonacci Sequence
- The **Fibonacci sequence** is a recursively defined sequence of numbers that shows up everywhere
    + Branching of trees, flower pedals, ...
- 
 It is defined by the recursion:
    + f(0) = 1
    + f(1) = 1
    + f(n) = f(n-1) + f(n-2)
- 
 Yields the sequence: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...