2420 Review Questions

1
2420 Review Questions

• Chapter 6

2
Complexity

• Finish the sentence We say a function f(n) is
  O(g(n)) if __________________
• Why is big oh notation used rather than precise
  timing?

3
Complexity

• If you have timing information, how do you tell
  if your big oh is correct?
• Give a big oh definition explaining the use of x0
  and c.
• What are the rules in doing math with big oh?
  Can we add, subtract, divide, multiply?

4
What is the complexity

• void doit( int n )
• if (n lt1) return
• int x x i
• doit(n/2)
• doit(n/2)

void doit( int n ) if (n lt1) return int x
x i doit(n/2)
5
What is the complexity

• void doit( int n )
• if (n lt1) return
• for (int i0 i lt n i)
• x x i
• doit(n/2)
• doit(n/2)

void doit( int n ) if (n lt1) return for
(i0 i lt n i) x x i doit(n/2)
6

• Theorem Assume T(n) aT(n/b) O(nk) is the
  time for the function.
• If a gt bk, the complexity is O(n logba).
• If a bk, the complexity is O(nk log n).
• If a lt bk, the complexity is O(nk).
• Using the formula approach, explain why mergesort
  and quicksort have the same complexity.

7
2420 Review Questions

• Chapter 8

8
Recursion

• Write a recursive method that has one parameter
  which is an int value called x. The method prints
  x asterisks, followed by x exclamation points. Do
  NOT use any loops. Do NOT use any variables other
  than x.

9
Implement the following recursive method. Do not
use any local variables or loops.

• The game starts when I give you some bears. You
  can then give back some bears, but you must
  follow these rules (where n is the number of
  bears that you currently have)
• 1. If n is even, then you may give back exactly
  n/2 bears.
• 2. If n is divisible by 3 or 4, then you may
  multiply the last two digits of n and give back
  this many bears. (By the way, the last digit of n
  is n10, and the next-to-last digit is
  ((n100)/10).
• 3. If n is divisible by 5, then you may give
  back exactly 42 bears.
• The goal of the game is to end up with EXACTLY 42
  bears.
• For example, suppose that you start with 250
  bears. Then you could make these moves
• --Start with 250 bears.
• --Since 250 is divisible by 5, you may return 42
  of the bears, leaving you with 208 bears.
• --Since 208 is even, you may return half of the
  bears, leaving you with 104 bears.
• --Since 104 is even, you may return half of the
  bears, leaving you with 52 bears.
• --Since 52 is divisible by 4, you may multiply
  the last two digits (resulting in 10) and return
  these 10 bears. This leaves you with 42 bears.
• --You have reached the goal so return TRUE
• bool canWin(int bearCt)

10

• Write a recursive solution to the following.
  Given ngt0, create a series of integers. The
  first line contains the number n. The next line
  is the number 2n. The next line is the number 4n,
  and so on until you reach a number that is larger
  than 1000. This list of numbers is then repeated
  backward until you get back to n.

Example output with n 40 40 80 160 320 640 640
320 160 80 40
11

• Write a recursive method with two int parameters,
  m and n. The precondition requires 0 lt m and m
  lt n. The method prints a line of m asterisks,
  then a line of m1 asterisks, and so on up to a
  line of n asterisks. Then the same pattern is
  repeated backward a line of n asterisks, then
  n-1, and so on down to n.

12
2420 Review Questions

• Chapter 9, Sorting

13

• Why do we have so many different kinds of sorts?

14

• Is a heap sort oblivious?
• Is a heap sort stable?

15
For each of the following algorithms, code the
pseudo code

• Bubble Sort
• Insertion Sort
• Selection Sort
• Shell Sort
• Quicksort
• Mergesort
• Heap sort

16
Quicksort

• Lots of improvements have been made to quicksort.
  Explain two of the most important.

17

• Since quicksort is faster than mergesort (yet has
  the same complexity), why would we ever use
  mergesort?