Computer Science 101 A Survey of Computer Science

1
Computer Science 101A Survey of Computer Science

• Efficiency of Divide and Conquer

2
Background - Logarithms (Base 2)

• Definition. The logarithm to base 2 of n is that
  number k such that 2kn.
• Example 2532 so Lg(32)5.
• Another way to think of this is that Lg(n) is the
  number of times we must divide n by 2 until we
  get 1.
• Note Lg(n) is usually a fraction, but the
  closest integer will work for us.

3
Base 2 Logarithms - Table

• n Lg(n) n
  Lg(n)1 0 1024
  10 2 1 2048 114 2 4096
  128 3 8192 1316 4 1,048,576 20
  32 564 6128 7256 8 512 9

4
Quicksort - Rough Analysis

• For simplification, assume that we always get
  even splits when we partition.
• When we partition the entire list, each element
  is compared with the pivot - approximately n
  comparisons.

5
Quicksort - Rough Analysis (cont.)

• Each of the halves is partitioned, each taking
  about n/2 comparisons, thus about n more
  comparisons.
• Each of the fourths is partitioned,each taking
  about n/4 comparisons - n more.

6
Quicksort - Rough Analysis (cont.)

• How many levels of about n comparisons do we
  get?
• Roughly, we keep splitting until the pieces are
  about size 1.

7
Quicksort - Rough Analysis (cont.)

• How many times must we divide n by 2 before we
  get 1?
• Lg(n) times, of course.
• Thus Comparisons ? n Lg(n)
• Quicksort is O(n Lg(n)) and T(n) ? KnLg(n)
  (Linearithmic)

8
Growth rates
9
Binary Search Algorithm

• Note For searching sorted list
• Given n, N1,N2,Nn (sorted) and target T
• Want Position where T is located or message
  indicating that T is not in list

10
Binary Search - The algorithm

• Set Found to falseSet B to 1Set E to nWhile
  not Found and B E Set M to (BE)/2 (whole
  part) If N(M)T then Print M Set Found to
  true else If TltNM then Set E to M-1
  else Set B to M1end-of-loopIf not Found
  then Print Target not in list

11
Binary Search Example
Output location 9
12
Binary Search Example
13
Binary Search Example (cont.)
Output location 5
14
Efficiency - Binary Search

• Note with 1000 elements, Sequential Search would
  have a worst case number of comparisons of 1000.
• After 1 comparison, Binary Search would be left
  with at most 500 elements.
• After 2 comparisons 250 at worst
• After 3 comparisons 125 at worst
• After 4 comparisons 62 at worst
• After 5 comparisons 31 at worst
• After 6 comparisons 15 at worst
• After 7 comparisons 7 at worst
• After 8 comparisons 3 at worst
• After 9 comparisons 1 at worst

15
Efficiency - Binary Search (cont)

• Each time we make a comparison, we cut the list
  in half.
• How many times must we do this to end up with 1
  element?
• Lg(n), of course.
• Binary search is O(Lg(n))
• T(n) ? K Lg(n)

16
Growth rates
17
If it takes that long for 100, we'll dang well be
here all night!