1 / 28

Algorithms

Algorithms. Step-by-step instructions that tell a computing agent how to solve some problem using only finite resources Resources Memory CPU cycles Time/Space Types of instructions Sequential Conditional If statements Iterative Loops. Pseudocode: The Interlingua for Algorithms.

nero-cross
Download Presentation

Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Algorithms Step-by-step instructions that tell a computing agent how to solve some problem using only finite resources Resources Memory CPU cycles Time/Space Types of instructions Sequential Conditional If statements Iterative Loops

  2. Pseudocode: The Interlingua for Algorithms an English-like description of the sequential, conditional, and iterative operations of an algorithm no rigid syntax. As with an essay, clarity and organization are key. So is completeness.

  3. Pseudocode Example Find Largest Number Input: A list of positive numbers Output: The largest number in the list Procedure: 1. Set Largest to zero 2. Set Current-Number to the first in the list 3. While there are more numbers in the list 3.1 if (the Current-Number > Largest) then 3.1.1 Set Largest to the Current-Number 3.2 Set Current-Number to the next one in the list 4. Output Largest

  4. Pseudocode Example Find Largest Number Input: A list of positive numbers Output: The largest number in the list Procedure: 1. Set Largest to zero 2. Set Current-Number to the first in the list 3. While there are more numbers in the list 3.1 if (the Current-Number > Largest) then 3.1.1 Set Largest to the Current-Number 3.2 Set Current-Number to the next one in the list 4. Output Largest conditional operation

  5. Pseudocode Example Find Largest Number Input: A list of positive numbers Output: The largest number in the list Procedure: 1. Set Largest to zero 2. Set Current-Number to the first in the list 3. While there are more numbers in the list 3.1 if (the Current-Number > Largest) then 3.1.1 Set Largest to the Current-Number 3.2 Set Current-Number to the next one in the list 4. Output Largest iterative operation

  6. Pseudocode Example Find Largest Number Input: A list of positive numbers Output: The largest number in the list Procedure: 1. Set Largest to zero 2. Set Current-Number to the first in the list 3. While there are more numbers in the list 3.1 if (the Current-Number > Largest) then 3.1.1 Set Largest to the Current-Number 3.2 Set Current-Number to the next one in the list 4. Output Largest Let’s “play computer” to review this algorithm…

  7. Algorithms vary in efficiency Algorithm I 1. Set sum to 0 2. Set currNum to 1 3. Repeat until currNum > n 4. Set sum to sum + currNum 5. Set currNum to currNum + 1 example: sum the numbers from 1 to n efficiency space= 3 memory cells time = t(step1) + t(step 2) + n t(step 4) + n t(step 5) • space requirement is constant (i.e. independent of n) • time requirement is linear (i.e. grows linearly with n).This is written “O(n)” to see this graphically...

  8. Algorithm Is time requirements time y = mx + b time = m n + b 0 1 2 … n size of the problem The exact equation for the line is unknown because we lack precise values for the constants m and b. But, we can say: time is a linear function of the size of the problem time = O(n)

  9. Algorithm II for summation } This algorithm requires a single multiplication! sum = 50 x 101 First, consider a specific case: n = 100. The “key insight”, due to Gauss: the numbers can be grouped into 50 pairs of the form: 1 + 100 = 101 2 + 99 = 101 . . . 50 + 51 = 101 Second, generalize the formula for any (even) n : sum = (n / 2) (n + 1) Time requirement is constant. time = O(1)

  10. Sequential Search: A Commonly used Algorithm Suppose you want to a find a student in the UT directory. It contains EIDs, names, phone numbers, lots of other information. You want a computer application for searching the directory: given an EID, return the student’s phone number. You want more, too, but this is a good start…

  11. Sequential Search of a student database name EID major credit hrs. 1 John Smith JS456 physics 36 2 Paula Jones PJ123 history 125 3 Led Belly LEB900 music 72 . . . . . . . . . . . . n Chuck Bin CB1235 math 89 1. ask user to enter EID to search for 2. set i to 1 3. set found to ‘no’ 4. while i <= n and found = ‘no’ do if EID = EIDi then set found to ‘yes’ else increment i by 1 7. if found = ‘no’ then print “no such student” else < student found at array index i > algorithm to search database by EID :

  12. Time requirements for sequential search • best case (minimum amount of work): EID found in student1 one loop iteration • worst case (maximum amount of work): EID found in studentn n loop iterations amount of work • average case (expected amount of work): EID found in studentn/2 n/2 loop iterations because the amount of work is a constant multiple of n, the time requirement is O(n) in the worst case and the average case.

  13. O(n) searching is too slow Consider searching UT’s student database using sequential search on a computer capable of 20,000 integer comparisons per second: n = 150,000 (students registered during past 10 years) average case 150,000 comparisons 1 seconds = 3.75 seconds 2 20,000 comparisons x worst case 150,000 comparisons x 1 seconds = 7.5 seconds 20,000 comparisons Bad news for searching NYC phone book, IRS database, ...

  14. Searching an ordered list is faster: an example of binary search student name student major credit hrs. 1 John Smith 24576 physics 36 2 Paula Jones 36794 history 125 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 24576 36794 38453 41200 43756 45987 47865 49277 51243 58925 59845 60011 60367 64596 86756 93687 3 Led Belly 42356 music 72 . . . . . . . . . . . . n Chuck Bin 93687 math 89 note: the student array is sorted in increasing order Probe 1 Probe 3 Probe 2 how would you search for 58925 ? 38453 ? 46589 ?

  15. The binary search algorithm What does this mean? How? How? assuming that the entries in student are sorted in increasing order, 1. ask user to input studentNum to search for 2. set found to ‘no’ 3. while not done searchingand found = ‘no’ 4. set middle to the index counter at the middle of the student list 5. if studentNum = studentmiddle then set found to ‘yes’ 6. if studentNum < studentmiddle then chop off the last half of the student list 7. If studentNum > studentmiddle then chop off the first half of the student list 8. if found = ‘no’ then print “no such student” else <studentNum found at array index middle>

  16. The binary search algorithm assuming that the entries in student are sorted in increasing order, 1. ask user to input studentNum to search for 2. set beginning to 1 3. set end to n 4. set found to ‘no’ 5. while beginning <= end and found = ‘no’ 6. set middle to (beginning + end) / 2 {round down to nearest integer} 7. if studentNum = studentmiddle then set found to ‘yes’ 8. if studentNum < studentmiddle then set end to middle - 1 9. if studentNum > studentmiddle then set beginning to middle + 1 10.if found = ‘no’ then print “no such student” else <studentNum found at array index middle>

  17. Time requirements for binary search At each iteration of the loop, the algorithm cuts the list (i.e. the list called student) in half. In the worst case (i.e. when studentNum is not in the list called student) how many times will this happen? n = 16 1st iteration 16/2 = 8 2nd iteration 8/2 = 4 3rd iteration 4/2 = 2 4th iteration 2/2 = 1 the number of times a number n can be cut in half and not go below 1 is log2 n. Said another way: log2 n = m is equivalent to 2m = n In the average case and the worst case, binary search is O(log2 n)

  18. This is a major improvement n sequential search binary search O(n) O(log2n) 100 100 7 150,000 150,000 18 20,000,000 20,000,000 25 27=128 218=262,144 225 is about 33,000,000 number of comparisons needed in the worst case in terms of seconds... 150,000 comparisons x 1 second = 7.5 seconds 20,000 comparisons sequential search: vs. binary search: 18 comparisons x 1 second > .001 seconds 20,000 comparisons

  19. Sorting a list unsorted sorted unsorted sorted unsorted sorted unsorted sorted 1 2 3 4 5 35467 67854 46781 13528 87341 1 2 3 4 5 35467 67854 46781 13528 87341 13528 1 2 3 4 5 35467 67854 46781 13528 87341 13528 35467 1 2 3 4 5 35467 67854 46781 13528 87341 13528 35467 46781 initially 1st iteration 2nd iteration 3rd iteration etc. First, an algorithm that’s easy to write, but is badly inefficient...

  20. The “Simple Sort” Algorithm given a list of positive numbers, unsorted1, …, unsortedn and another list, sorted1, …, sortedn, with all values initially set to zero 1. set i to 1 2. repeat until i > n set indexForSmallest to the index of the smallest positive value in unsorted 4. set sortedi to unsortedindexForSmallest 5. set unsortedindexForSmallest to 0 6. increment i

  21. This algorithm is expensive! Time requirement total time = n iterations x time per iteration time per iteration = time to find smallest value in a list of length n = O(n) total time = nx O(n) = O(n2) Space requirement total space = space for unsorted + space for sorted = O(2n)

  22. Creating Algorithms is the Challenge of Computer Science A salesperson wants to visit 25 cities while minimizing the total number of miles driven, visiting each city exactly once, and returning home again. Which route is best? It’s not easy; try this one: The Traveling Salesperson problem:

  23. Simplify the Problem to get an intuition about it A B four cities connected by roads C D start at A, visit B, C, and D in some order, then return to A One algorithm to answer the question: 1. generate all possible routes of length 5 2. check each path to determine whether it meets the requirement Q: Starting at A, what’s the shortest route that meets the requirements? A: Obvious to anyone who looks at the entire map. Not so obvious to an algorithm that “sees”, at any one time, only one city and its roads How much time does this algorithm require?

  24. All Paths from A of length 5 A B C A D A D B C B C B C B C A D A D A D A D A D A D A D A D A B C D Number of paths to generate and check is 24 = 16.

  25. Can you Improve the Algorithm? Prune bad routes as soon as possible. What’s a “bad route?” Look for good solutions, even if they’re sub-optimal. What’s a “good solution?”

  26. This gets real bad, real fast! In general, the algorithm’s time requirement is: (the number of roads in&out of a city) number of cities Assuming the number of roads is only 2, the time requirement is 2number of cities, given by the powers of 2 table. Assuming a computer could evaluate 10 million routes per second, finding the best route for 25 cities would require about 3.5 seconds. No problem! However, finding the best route for 64 cities would require about seconds, or hours! 20 million 5000

  27. Comparing the time requirements n work 2n n2 order 10 50 100 1,000 35 30 25 20 15 10 5 0 log2n .0003 .0006 .0007 .001 n .0001 .005 .01 .1 n2 .01 .25 1 1.67 min 2n .1024 3570 4x1016 forget it! years centuries n time requirements for algorithms of various orders of magnitude. Time is in seconds, unless stated otherwise log2n n 0 5 10 15

  28. Conclusions Algorithms are the key to creating computing solutions. The design of an algorithm can make the difference between useful and impractical. Algorithms often have a trade-off between space (memory) and time.

More Related