big oh
play

Big-Oh 1 asymptotic growth rate or order compare two functions, but - PowerPoint PPT Presentation

Nov 21, 2022 •243 likes •1.11k views

Big-Oh 1 asymptotic growth rate or order compare two functions, but ignore constant factors, small inputs example: ; grows faster eventually much bigger than goal: predict behavior here ignore behavior here 2 asymptotic growth rate

  1. Big-Oh 1

  2. asymptotic growth rate or order compare two functions, but… ignore constant factors, small inputs example: ; grows faster — eventually much bigger than goal: predict behavior here ignore behavior here 2

  3. asymptotic growth rate or order compare two functions, but… ignore constant factors, small inputs goal: predict behavior here ignore behavior here 2 example: f ( n ) = 1 000 000 · n 2 ; g ( n ) = 2 n g grows faster — eventually much bigger than f

  4. asymptotic growth rate or order compare two functions, but… ignore behavior here goal: predict behavior here 2 ignore constant factors, small inputs example: f ( n ) = 1 000 000 · n 2 ; g ( n ) = 2 n g grows faster — eventually much bigger than f 2 · 10 9 1 . 5 1 0 . 5 0 5 10 15 20 25 30 35

  5. asymptotic growth rate or order compare two functions, but… ignore behavior here goal: predict behavior here 2 ignore constant factors, small inputs example: f ( n ) = 1 000 000 · n 2 ; g ( n ) = 2 n g grows faster — eventually much bigger than f 2 · 10 9 1 . 5 1 0 . 5 0 5 10 15 20 25 30 35

  6. asymptotic growth rate or order compare two functions, but… ignore behavior here goal: predict behavior here 2 ignore constant factors, small inputs example: f ( n ) = 1 000 000 · n 2 ; g ( n ) = 2 n g grows faster — eventually much bigger than f 2 · 10 9 1 . 5 1 0 . 5 0 5 10 15 20 25 30 35

  7. preview: what functions? example: comparing sorting algorithms 3 runtime = f ( size of input ) e.g. seconds to sort = f ( number of elements in list ) e.g. # operations to sort = f ( number of elements in list ) space = f ( size of input ) e.g. number of bytes of memory = f ( number of elements in list )

  8. theory, not empirical yes, you can make guesses about big-oh behavior from measurements what happens further to the right? might not have tested big enough example: summing a list of items: exactly addition operations assume each one takes unit of time runtime 4 but, no, graphs � = big-oh comparison want to write down formula

  9. theory, not empirical yes, you can make guesses about big-oh behavior from measurements what happens further to the right? might not have tested big enough 4 but, no, graphs � = big-oh comparison want to write down formula example: summing a list of n items: exactly n addition operations assume each one takes k unit of time runtime = f ( n ) = kn

  10. recall: comparing list data structures others seem to remain manageable 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 2.609 s some runtimes get really big as size gets large… problem: growth rate of runtimes with list size 0.004 s for Vector (unsorted), ArrayList , LinkedList … # operations grows like where is list size for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … # operations per search grows like where is list size TreeSet 0.003 List benchmark (from intro slides) w/ 100000 elements ArrayList Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 24.612 s 87.192 0.022 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 0.029 5

  11. recall: comparing list data structures others seem to remain manageable 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 2.609 s some runtimes get really big as size gets large… problem: growth rate of runtimes with list size 0.004 s for Vector (unsorted), ArrayList , LinkedList … # operations grows like where is list size for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … # operations per search grows like where is list size TreeSet 0.003 List benchmark (from intro slides) w/ 100000 elements ArrayList Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 24.612 s 87.192 0.022 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 0.029 5

  12. recall: comparing list data structures others seem to remain manageable 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 2.609 s some runtimes get really big as size gets large… problem: growth rate of runtimes with list size 0.004 s for Vector (unsorted), ArrayList , LinkedList … # operations grows like where is list size for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … # operations per search grows like where is list size TreeSet 0.003 List benchmark (from intro slides) w/ 100000 elements ArrayList Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 24.612 s 87.192 0.022 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 0.029 5

  13. recall: comparing list data structures others seem to remain manageable 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 2.609 s some runtimes get really big as size gets large… problem: growth rate of runtimes with list size 0.004 s for Vector (unsorted), ArrayList , LinkedList … # operations grows like where is list size for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … # operations per search grows like where is list size TreeSet 0.003 List benchmark (from intro slides) w/ 100000 elements ArrayList Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 24.612 s 87.192 0.022 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 0.029 5

  14. recall: comparing list data structures 2.609 s TreeSet 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 some runtimes get really big as size gets large… 0.003 others seem to remain manageable problem: growth rate of runtimes with list size for Vector (unsorted), ArrayList , LinkedList … for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … # operations per search grows like where is list size 0.004 s 0.022 List benchmark (from intro slides) w/ 100000 elements 24.612 s Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 ArrayList 0.029 87.192 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 5 # operations grows like n where n is list size

  15. recall: comparing list data structures others seem to remain manageable 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 2.609 s some runtimes get really big as size gets large… problem: growth rate of runtimes with list size 0.004 s for Vector (unsorted), ArrayList , LinkedList … # operations grows like where is list size for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … # operations per search grows like where is list size TreeSet 0.003 List benchmark (from intro slides) w/ 100000 elements ArrayList Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 24.612 s 87.192 0.022 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 0.029 5

  16. recall: comparing list data structures 2.609 s TreeSet 0.134 0.110 0.017 0.007 s Vector , sorted 2.642 0.009 0.024 some runtimes get really big as size gets large… 0.003 others seem to remain manageable problem: growth rate of runtimes with list size for Vector (unsorted), ArrayList , LinkedList … # operations grows like where is list size for HashSet … # operations per search/remove is constant (sort of) for TreeSet , sorted Vector … 0.004 s 0.022 List benchmark (from intro slides) w/ 100000 elements 24.612 s Data structure Total Insert Search Delete Vector 87.818 0.004 63.202 ArrayList 0.029 87.192 0.010 62.470 24.712 s LinkedList 263.776 0.006 196.550 67.439 s HashSet 5 # operations per search grows like log( n ) where n is list size

  17. can fjnd out before implementing algorithm why asymptotic analysis? “can my program work when data gets big?” website gets thousands of new users? text editor opening 1MB book? 1 GB log fjle? text search on 100 petabyte copy of the text of the web? if asymptotic analysis says “no” won’t be fjxed by, e.g., buying a faster CPU 6 music player sees 1 000 song collection? 50 000 ?

  18. why asymptotic analysis? “can my program work when data gets big?” website gets thousands of new users? text editor opening 1MB book? 1 GB log fjle? text search on 100 petabyte copy of the text of the web? if asymptotic analysis says “no” won’t be fjxed by, e.g., buying a faster CPU 6 music player sees 1 000 song collection? 50 000 ? can fjnd out before implementing algorithm

  19. sets of functions examples: — ignore constant factor, etc. and and 7 defjne sets of functions based on an example f Ω( f ) : grow no slower than f (“ ≥ f ”) O ( f ) : grow no faster than f (“ ≤ f ”) Θ( f ) = Ω( f ) ∩ O ( f ) : grow as fast as f (“ = f ”)

  20. sets of functions examples: 7 defjne sets of functions based on an example f Ω( f ) : grow no slower than f (“ ≥ f ”) O ( f ) : grow no faster than f (“ ≤ f ”) Θ( f ) = Ω( f ) ∩ O ( f ) : grow as fast as f (“ = f ”) n 3 ∈ Ω( n 2 ) 100 n ∈ O ( n 2 ) 10 n 2 + n ∈ Θ( n 2 ) — ignore constant factor, etc. and 10 n 2 + n ∈ O ( n 2 ) and 10 n 2 + n ∈ Ω( n 2 )

  21. what are we measuring is big-oh of ” informally: “ ‘ is not big-omega of ) or ( example ” informally: “ ) (or example: to another function will comapre 8 f ( n ) = worst case running time n = input size — as a positive integer

Recommend

More recommend