Data Structures Ozbirn Exam 1 Super Set

What are the four basic rules when writing recursive routines (in summary)?

Base case, making progress towards the base case, assume recursive calls work without tracing it all out, don't duplicate work already performed in a previous call.

What is the first basic rule of recursion

Basic case: which can be solved without recursion

Upper bound (possibly equal).

Big O

What is the fourth basic rule of recursion?

Compound interest rule: don't duplicate work already performed in a previous call

What is the third step of an inductive proof?

Conclusion: by induction, the theorem holds for all cases i.e. the minimal case and all its successors

What is Big-O rule #3?

Consecutive statements add (which means the maximum one is the one that counts).

What is the third basic rule of recursion?

Design rule: assume recursive calls work without tracing it all out

A queue is known as a

FIFO- First in first out; a queue is another kind of simplified list; add at back, delete/peek at the front; Its like a line at a grocery store; the first one in is the first one that comes out.

Traversing a list of N items using the following loop is O(N) if wordlist is an ArrayList, but O(N2) if it is a LinkedList. for (String str: wordlist) { System.out.println(str); }

False

What is Big-O rule #1?

For-loops. Number iterations (n) times the statements inside.

Why is this good code? public class GenericMemoryCell<AnyType> { public AnyType read() { return storedValue; } public void write(AnyType x) { storedValue = x; } private AnyType storedValue; } public class TestGenericMemoryCell { public static void main(String [] args) { GenericMemoryCell<Integer> m = new GenericMemoryCell<Integer> ( ); m.write( 37 ); int val = m.read(); System.out.println("Cell contents: " + val ); } }

If this is anything but an integer you get a compile error as opposed to runtime error

What is Big-O rule #4?

If-else statements are the test plus the larger of the two branches.

What is the second step of an inductive proof?

Inductive step: a. inductive hypothesis: assume theorem holds for all cases up to some limit k, b. prove the next case for example, k+1

What is inheritance?

Inheritance is a mechanism in which one object acquires all the properties and behaviour of another object of another class. It represents IS-A relationship. It is used for Code Resusability and Method Overriding.

A Stack is known as

LIFO- Last in First out; can only add, remove and delete from one end

Upper bound (not equal)

Little o

What is the second basic rule of recursion?

Making progress: each recursive call makes progress towards the base case

What is faster N log N or N?

N

What is faster: N^2 or N log N

N log N

What is faster N^3 or N^2?

N^2

What is faster: 2^N or N^3

N^3

What is Big-O rule #2?

Nested for-loops. Statements inside times the product of loop sizes.

Consider this method header: public static <AnyType extends Comparable<? super AnyType>> AnyType findMax(AnyType [] arr)

Now if Square extends Shape and implements Comparable<Shape>, it is accepted, since Shape is a superclass of Square. Super says the comparable can be on my super class

What is the big-Oh of a merge and quick sort?

O (N log N), faster than N^2, so doubling the list size increases the work by a little more than double

f(n) = 4

O(1)

What methods does the LinkedList use from the List interface?

O(1) add/remove at beginning/end, add/remove if have access to location O(N) add/remove from middle, access/search

What methods does the ArrayList use from List interface?

O(1) add/remove at end, Access O(N) search, add/remove from beginning/middle

What is the big-Oh of a sequential search?

O(N)

What is the Big-O notation of 2N^2 + N + 5

O(N^2)

What is the big-Oh of a insertion and selection sort?

O(N^2), faster than log N so doubling the list size quadruples the amount of work

what is the Big-O notation of N^3 + N^2

O(N^3)

What is the big-Oh of a binary search?

O(log N), faster than O(N), if the number of operations required to solve a problem is proportional to the logarithm of the size of the problem

f(n) = 4log(n)

O(log(n))

f(n) = 3n + 1

O(n)

f(n) = n

O(n)

f(n) = 60n^2 + 5n + 1

O(n^2)

Lower bound (possibly equal).

Omega

What is the difference between Arraylists vs. LinkedLists?

Shifting indexes in array lists will affect the O(N), a linked lists will not do this.

Why is this bad code? public class MemoryCell { public Object read() { return storedValue; } public void write(Object x) { storedValue = x; } private Object storedValue; } public class TestMemoryCell { public static void main(String [] args) { MemoryCell m = new MemoryCell ( ); m.write(new Integer(5)); Integer wval = (Integer) m.read(); int val = wval.intValue(); System.out.println("Cell contents: " + val ); } }

There would be a runtime error if you cast the object the wrong way with m.read();

Growth rates are equal

Theta

T/F T(N) = O(f(N)) means that T(N) <= cf(N) for some constant c and for N >= n0.

True

T/F T(N) = Θ (f(N)) means that T(N) = cf(N) for some constant c and for N >= n0.

True

T/F T(N) = Ω(f(N)) means that T(N) >= cf(N) for some constant c and for N >= n0.

True

The cost of executing merge sort on a list of N items can be characterized by the recursive function: Cost(N) = 2*Cost(N/2) + C1*N + C2

True

Traversing a list of N items using the following loop is O(N) if wordlist is an ArrayList, but O(N2) if it is a LinkedList. for (int i = 0; i < wordlist.size(); i++) { System.out.println(wordlist.get(i)); }

True

T/F GenericMemoryCell<Integer> m = new GenericMemoryCell<Integer> ( ); can be written as GenericMemoryCell<Integer> m = new GenericMemoryCell< > ( );

True, this shows a use of the diamond operator, once the integer has already been specified it does not need typing again

X^a*X^b =

X^(a+b)

X^a/X^b

X^(a-b)

(X^a)^b

X^(ab)

If a Person class has a subclass of Employee, then it is possible to write: Person x = new Employee(); But what about arrays? Person x[] = new Employee[5]; Can you make a person x array to be a new array of employee? Yes, this is allowed

Yes because of the "is a" relationship, these arrays in Java are "covariant", so the assignment works

What would happen if a string and not 30 were passed? public class GenericMemoryCell<AnyType> { public AnyType read() { return storedValue; } public void write(AnyType x) { storedValue = x; } private AnyType storedValue; } public class TestGenericMemoryCell { public static void main(String [] args) { GenericMemoryCell<Integer> m = new GenericMemoryCell<Integer> ( ); m.write( 37 ); int val = m.read(); System.out.println("Cell contents: " + val ); } }

You would get a compile time error

What is a class?

a class defines a new type of object

What is the Java Collections framework?

a collection is an object (i.e., data structure) that holds other objects

What does a List Interface do?

an interface defines a generic template for a class --specifies the methods that the class must implement --but, does not specify fields nor method implementations

What is the first step of an inductive proof?

base case

What is the fastest function?

c Constant

You ______ create a new instance of a generic type

can't

You ________ create an array of generic type

can't

You _________ use a class's type variable in static field's or methods

cannot

What is cohesion?

describes how well a unit of code maps to an entity or behavior

What is coupling?

describes the interconnectedness of classes in a loosely coupled system: each class is largely independent and communicates with other classes via a small, well-defined interface

What are things that are in a class?

fields are variables that belong to the object (and maintain its state) note: "this." is optional, but instructive methods define the actions that can be performed on an object typically public, so can be called by client code a constructor is a special method that automatically initializes the object when it is created can have more than one constructor

Is GenericMemoryCell<int> is legal or illegal?

illegal because you can't use primitive types for generics

For big O model we pretend memory is ________

infinite

public static <AnyType extends Comparable<AnyType>> AnyType findMax(AnyType [] arr) If Shape implements Comparable<Shape>, it is accepted, but if Square extends Shape and implements Comparable<Shape>, _____________

it is not

What can the Collections interface be used for?

java.util.Collections provides a variety of static methods on Lists static int binarySearch(List<T> list, T key) static T max(List<T> list); static T min(List<T> list); these methods can be called on both ArrayLists and LinkedLists

What is faster: log N or log^2 N

log N

what is faster: log^2 N or N

log^2 N

logaB =

logcB / logcA

X^a = B if and only if ______

logxB = A

What consists of Java arrayLists?

must specify content type when declare, capacity is optional (default is 0) can be dynamically expanded/reduced; can easily add/remove from middle

Can you have an array of a generic class?

no

Analyze the following code: public class GenericMemoryCell<AnyType> { public AnyType read() { return storedValue; } public void write(AnyType x) { storedValue = x; } private AnyType storedValue; } if there were a counter as a method, would it be AnyType as well?

no, it would just be an integer, you want 0 1 2 3 ... not a string or whatever else

What does the following mean? comparable< ? super AnyType>

now any subclass of the type can be passed successfully

There be ___ class for all generic invocations.

one

What is polymorphism?

polymorphism applies to classes in an inheritance hierarchy can pass a derived class wherever the parent class is expected the appropriate method for the class is called

What is public vs. private?

private, so can only be accessed from within the class public can be accessed from outside of the class

instanceof and typecasts work only with ___________

raw types

When is recursion useful?

recursion is useful when a task can be broken down into smaller, similar tasks functional recursion: a method directly or indirectly calls itself

Generic classes are seen by the compiler but are converted to _________________________________, this process is known as type erasure.

regular classes (called raw classes) during compilation.

How to search a list?

sequential search traverses the list from beginning to end check each entry in the list if matches the desired entry, then FOUND (return its index) if traverse entire list and no match, then NOT FOUND (return -1) recall: the ArrayList class has indexOf, contains methods

What consists of java arrays?

stored contiguously, with each item accessible via an index must specify content type when declare, size when create once created, the size cannot be changed (without copying entire contents)

What are the benefits of a LinkedList? What makes it better than an ArrayList?

stores elements in a sequence but allows for more efficient interior insertion/deletion elements contain links that reference previous and successor elements in the list

Why do we need a base case?

to prevent from running out of stack space memory

T/F T(N) > o(f(N)) means that T(N) < cf(N) for some constant c and for N >= n0.

true

Proof by Counterexample is __________

where you simply show a case where it isn't true

We look at _______ case, mostly

worst

what is the base case? public static void print(int n) { if (n >= 10) print( n / 10); printDigit( n % 10); }

9 or less

for the following code what is the output: public static int power(int x, int n) { if (n = = 0) return 1; else return x * power(x, n-1); } power(5, 2)

25, = 5*(5 * power(5, 1)) =5*(5 * ( 5 * power(5, 0)

X^n + X^n

2X^n

2^n + 2^n

2^(n+1)

How many basic rules are for when writing recursive routines

4 basic rules

Suppose it took 10 seconds to sort a list of N items using selection sort (where N is a large number). Recall that selection sort is an O(N2) algorithm. Which of the following would be the most likely timing for selection sorting a list of 2N items?

40 seconds

What does the following code print if 6371 is passed in as n? public static void print(int n) { if (n >= 10) print( n / 10); printDigit( n % 10); }

6 ( printDigit(6%10); ) 3 ( printDigit(63%10); ) 7 ( printDigit(637%10); ) 1 ( printDigit(6371%10); )

What does a single linked lists consist of?

-has a front and a back -great for stacks and queues -each node has a data value and an address

What is the step by step process of figuring out the cost of recursion or Big Oh?

1) find relationship between C and T; as long as n> or = 1 2) Take away the negative terms (bc it makes the equation bigger) 3) Multiply the the terms together 4) Add the constants together and you get the term n^3

Suppose it took 10 seconds to sort a list of N items using merge sort (where N is a large number). Recall that merge sort is an O(N log N) algorithm. Which of the following would be the most likely timing for merge sorting a list of 2N items?

22 seconds