Download presentation

Presentation is loading. Please wait.

1
**Algorithms (continued)**

2
**Pseudocode Set i = 1 While i < 10**

1. print [i “bottles of beer on a stone”] 2. print [i “bottles of beer”] 3. print [“if one of those bottles should happen to clone”] 4. print [i+1 “bottles of beer on a stone”] 5. INCREMENT i (i = i+1 or “i++”)

3
**Pseudocode Set num = 0, set sum = 0**

While there are more numbers to be read 1. read(x) (let x = next number read) 2. sum = sum + x (increment sum by x) 3. num (increment num by 1) Output: sum/num Walk through this code and see what happens. Set up boxes for num, sum, x. Use data 3, 5, 2, 8, 7 walk through code with data = 3, 5, 2, 8, 7

4
**Pseudocode GCD (a, b) While remainder r is not 0**

1. find q, and r < b, so that a=bq+r 2. set a = b set b = r Output a What would effect be if we switched the two assignment statements in step 2.?

5
**stepping through code for understanding for debugging a b q r**

GCD (a, b) While remainder r is not 0 1. find q and r < b so that a=bq+r 2. set a = b set b = r Output a for understanding for debugging a b q r 42 15 ? Initial values 42 15 2 12 after step 1 15 12 2 after step 2 15 12 1 3 step 1 (2nd time) 12 3 1 step 2 (2nd time) 12 3 4 step 1 (3rd time) 3 4 step 2 (3rd time)

6
**Linear Search Assume data M(0) … M(n)**

Input x; Find memory location i such that M(i)=x (or report that x is not in list) Linear_search (x) i = 0 WHILE i < n+1 IF M(i) = x then halt and output i ELSE i = i+1 Output “not in the list”. Example use: suppose we had UINs stored in memory, each followed by a phone number. Goal is to find phone number of person with given UIN. How many steps does it take when Linear_search is run?

7
**Binary Search Assume sorted data M(0) … M(n) Binsearch (x)**

put left, right fingers on 0 and n let midpoint be the point halfway between. WHILE x not equal M(midpoint) IF M(midpoint) < x THEN move left finger to midpoint ELSE move right finger to midpoint set midpoint halfway between fingers END WHILE

8
**Binary Search Assume sorted data M(0) … M(n) Binsearch (x) left = 0**

right = n midpoint = (left + right) / 2 WHILE x notequal M(midpoint) IF M(midpoint) < x THEN left = midpoint ELSE right = midpoint END WHILE Give warning about left+right/2 need to round/truncate, and careful consideration of ending condition…. might need to end when left and right are one apart. This actually has several bugs. Can you figure out what they are?

9
**stepping through binary search**

ARRAY M( ) M(0) = 3 M(1) = 4 M(2) = 6 M(3) = 21 M(4) = 24 M(5) = 27 M(6) = 28 M(7) = 30 M(8) = 31 M(9) = 33 M(10)= 39 M(11)= 44 M(12)= 45 M(13)= 48 M(14)= 50 M(15)= 55 M(16)= 57 left right midpoint searching for 33 16 ? Initial values 16 8 compute midpt 8 16 move left 8 16 12 compute midpt 8 12 move right 8 12 10 compute midpt 8 10 move right 8 10 9 compute midpt

10
**Running Times Binary Search At each iteration, range is cut in half**

Total number of iterations to find an item among N elements is y such that “cut N in half y times to get down to 1” Yes, this is just (base 2) log N Searching among 2300 elements takes only 300 steps (this exceeds the number of particles in the universe!!) Ask class to determine number of queries for input of size 1024.

11
**Linear search vs. Binary search**

12
**Sorting Algorithms Different methods to put things in order**

Which are fastest methods?

13
**Bubble Sort Put left, right fingers on M(0), M(1)**

IF M(left) > M(right) THEN swap them Move left, right fingers to right IF right finger = n THEN done with this pass, start again BUT next time only go up to n-1 Etc., for passes ending at n-2, n-3, etc. Do bubble sort with volunteers, based on height.

14
**Aside: FOR loops new kind of iteration command (similar to WHILE)**

Example FOR i = 1 to 10 print 3*i FOR count = 100 downto 1 print count Outputs 3,6,9,…,30 Outputs 100,99,98,…,1

15
**Bubble Sort LET’S UNROLL THIS CODE TO MAKE SURE WE UNDERSTAND**

FOR max = n-1 downto 1 FOR left = 1 upto max right = left + 1 IF M(left) > M(right) THEN swap them make a pass up to position max Need to explain a “FOR” loop. LET’S UNROLL THIS CODE TO MAKE SURE WE UNDERSTAND

16
**Bubble Sort FOR max = n-1 downto 1 FOR left = 1 upto max**

right = left + 1 IF M(left) > M(right) THEN swap them make a pass up to position max Let max = n-1 blah blah blah Let max = n-2 … etc Let max = 2 Let max = 1 There are n-1 phases During a phase, what happens? A nested FOR loop is executed The nested loop moves from 1 to max and does a swap if necessary Let’s look at an example with n = 4

17
Bubble Sort FOR max = n-1 downto 1 FOR left = 1 upto max right = left + 1 IF M(left) > M(right) THEN swap them make a pass up to position max max = 3 IF M(1) > M(2) swap them IF M(2) > M(3) swap them IF M(3) > M(4) swap them max = 2 max = 1 Now we can see the effect of the inner loop for each “version” of the outer loop… …and the overall effect of the nested loops

18
**Correctness Why does it work?**

After first pass, the largest is in position n 2nd pass, the 2nd largest is in position n-1 3rd pass, the 3rd largest is in position n-2 etc. nth pass, the nth largest is in position 1

19
**Running time Count comparisons Don’t get bogged down in detail**

Iteration is the biggest contributor Bubble Sort: (n-1) + (n-2) + … = n(n-1)/2 = (n2-n)/2 = n2/2 - n/2 ≤ n2/2 Need to explain why the sum is n*(n-1)/2

20
**A presidential message**

21
**Insertion Sort (typical method for sorting playing cards in hand)**

Insert first Insert next into proper place etc.

22
Insertion Sort FOR i = 1 to n /* Insert M(i) into correct place in new list T() { j = /* Start looking at position T(1) WHILE M(i) < T(j) { j = j+1 } /* AHA! M(i) belongs right after T(j) slide T(j+1), T(j+2), … over to T(j+2), T(j+3)… T(j+1) = M(i) where slide is a separate “procedure” that we have written.

23
**Running Times Insertion Sort: 1 + 2 + 3 + 4 … + n-1**

≤ n2/2 (see previous analysis)

24
**Quick Sort A very fast method in practice**

Used often, especially with large data sets

25
**Quick Sort 1 5 9 4 7 Pick a “pivot’ at random 2 8 3 6 1 4 5 9**

Compare each element to the pivot, placing it to left or right 7 2 8 3 6 Pivot is in correct place. Now sort the left, right using Quick Sort method…..

26
**Quick Sort 1 4 5 9 Pick a pivot at random 7 2 8 3 6**

Compare each element to the pivot, placing it to left or right 1 2 3 4 7 9 5 6 8 Pivot is in correct place. Now sort the left, right using Quick Sort method…..

27
Quick Sort 1 4 9 5 7 2 6 3 8 5 6 8 9 4 7 3 1 2 etc... 3 4 5 6 7 8 9 1 2

28
**Quick Sort Quick Sort (in-class demo):**

depends on how lucky you are with “pivot” complex analysis shows on average, you are lucky running time on average can be shown to be about n log n

29
Running time matters n2 n log n n log n

30
Quick calculations Sort n=1,000,000,000 items with algorithms taking times n2, and n log n, on computers capable of doing 1,000,000,000 (a billion) comparisons per second? How much time is taken by each algorithm? Demo: sorting applets: Demo: asSORTed dances:

31
**Summary pseudocode stepping through code**

basic algorithms: linear search, binary search, different sorting algorithms notion of running time and computing approximate bounds to determine efficiency

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google