Lecture Date: Wednesday, November 16
Today we'll look at four particular algorithms that have been important in computing (well... at least in CS1) for a very long time.
Specifically:
 Linear Search
 Binary Search
 Insertion Sort
 Selection Sort
 Bubble Sort
 Merge Sort  if time...
We'll do some inclass activities to show exactly how these algorithms work. We won't really look at code yet  the purpose is to figure out just how "good" each of these algorithms is in various circumstances.
To search a list, we could:

Look at each element in turn, stopping when/if we find it. In python, this process becomes a simple
for
loop and is called Linear Search. If the list has n elements, the loop might repeat as many as n times. 
If we know the list is in some kind of order, look at the middle element and then consider only half the list, repeating until we find the element we want. This is called Binary Search If the list has n elements, we can cut it in half at most log_{2}(n) times.
To sort a list, we could:

Compare neighboring elements, swapping them if they are out of order. This is called Bubble Sort. In general, this requires us to look across the list repeatedly; roughly speaking, we have to walk the entire list (n elements) n times, so the program might take as much as n^{2} times.

Find the smallest value and move it to a new list, the repeat until we can moved them all. This is called Selection Sort. Finding an element (linear search) takes n time, and we have n of them to find, so we are still in n^{2} time overall, like bubble sort.

Take the next item in the list and then move it to the correct place by shifting the previous items. This is called Insertion Sort. Moving down the list (linear search) takes n time, and we may have to move n of them to find the right spot, so we are still in n^{2} time overall, like bubble sort.

Split the list in half, sort each half, and then merge the two halves in order. This is called Merge Sort. Merging in takes time proportional to n, and we can split at most log_{2}(n) times, for a total of n log_{2}(n) time.
As a point of context,
 There are around 8,000,000,000 people on Earth
 Suppose we can handle a million people per second

Then we expect
 linear search to take 8,000 seconds or about 2 hours
 binary search to take 0.000033 seconds
 bubble or selection sort to take over a trillion years, more than 70 times larger than the current estimated age of the universe
 merge sort to take 264,000 seconds or about 3 days
Note that all of these are approximate, but they within an order of magnitude of the right answers