Test Yourself #1

• constructor: This method allocates the initial array, sets current to -1 and sets numItems to 0. This has nothing to do with the sequence size and is constant-time.
• addAfter: In the worst case you add after the first item in the Sequence. In this case you must shift all the items except the first to the right one index and then insert the next item. The number of operation is proportional to the size of the sequence.
• start: This method sets current = -1 if numItems is zero; otherwise it sets current = 0. This is constant-time.
• getCurrent: If current is not valid it throws an exception. Otherwise it returns items[current]. In either case it is constant-time.
• lookup: In the worst case the item is not in the Sequence. In this case you have to look at each item in the sequence to determine it is not present. This is proportional to the size of the sequence.

Test Yourself #2

Question 1: The problem size is the number of people in the room.

Question 2: Assume there are N people in the room. In algorithm 1 you always ask 1 question. In algorithm 2, the worst case is if no one has your birthday. Here you have to ask every person to figure this out. This is N questions. In algorithm 3, the worst case is the same as algorithm 2. The number of questions is 1 + 2 + 3 + ... + N-1 + N. We showed before that this sum is N(N+1)/2.

Question 3: Given the number of questions you can see that algorithm 1 is constant time, algorithm 2 is linear time, and algorithm 3 is quadratic time in the problem size.

Test Yourself #3

1. The first loop is O(N) and the second loop is O(M). Since you don't know which is bigger, you say this is O(N+M). This can also be written as O(max(N,M)). In the case where the second loop goes to N instead of M the complexity is O(N). You can see this from either expression above. O(N+M) becomes O(2N) and when you drop the constant it is O(N). O(max(N,M)) becomes O(max(N,N)) which is O(N).
2. The first set of nested loops is O(N²) and the second loop is O(N). This is O(max(N²,N)) which is O(N²).
3. When i is 0 the inner loop executes N times. When i is 1 the inner loop executes N-1 times. In the last iteration of the outer loop when i is N-1 the inner loop executes 1 time. The number of times the inner loop statements execute is N + N-1 + ... + 2 + 1. This sum is N(N+1)/2 and gives O(N²).

Test Yourself #4

1. Each call to f(j) is O(1). The loop executes N times so it is N x O(1) or O(N).
2. The first time the loop executes j is 0 and g(0) takes "no operations". The next time j is 1 and g(1) takes 1 operations. The last time the loop executes j is N-1 and g(N-1) takes N-1 operations. The total work is the sum of the first N-1 numbers and is O(N²).
3. Each time through the loop g(k) takes k operations and the loop executes N times. Since you don't know the relative size of k and N, the overall complexity is O(N x k).

Test Yourself #5