CS 2114 Exam 1
When to use abstract classes?
If you want to provide a method definition Declare a private data field that your classes will have in common
Adding a node at the beginning
Node newNode = new Node(); newNode.data = 8; newNode.next = head; head = newNode;
Removing a node
p.next = q.next; q = p.next; for when q is right after p and you want to remove what q references
Assume a Queue class has been implemented as a circular array with one unused location. Next assume an instance of the Queue has been constructed with a default capacity of six, storing String references. Then the following six strings are inserted, (i.e., enqueued), into the Queue: "!", "@", "#", "$", "%", "?". Now the front of the queue is deleted, (i.e., dequeued) and another string, "&", is inserted (i.e., enqueued) Again the front of the queue is deleted and another string is immediately inserted. Assume this pattern, (dequeue, enqueue ...) paired operations is repeated an arbitrary number of times. Which of the following expressions best describes the resulting relationship between the frontIndex (first element in the queue) and backIndex (last element in the queue) indices of the queue after the final enqueue operation?
((backIndex + 2) % 7) == frontIndex
Of the two sorting algorithms we studied in lecture, which would do less work, in terms of comparisons and swaps, if executed upon an already sorted array?
--> Insertion Sort Not Selection Sort
What index does a stack's topINdex start at
-1
Lever-order traversal
Begin at root and visit nodes one level at a time
Where should you add nodes in a list
Beginning
Binary search efficiencies
Best case: O(1) Worst/average case: O(log n)
Insertion Sort Cases
Best: O(n) Average: O(n^2)
Protected methods
Can only be accessed in their own class, classes in the same package, or by any subclass
Downcast
Cast superclass to subclass type; checked with ClassCastException
Universal O(1) methods
Clear getLength isEmpty
Node class fields
Data = int Next = node
To implement a Deque(double ended queue) with a firstNode and a lastNode reference that only adds and removes data on the ends, which of the following underlying representations would result in the most efficient implementation?
Double linked chain
Easiest part of a stack array to access
End of the array
Abstract class vs interface
Extend class Implement interface
Fairness
How can I act equitably and balance legitimate interests?
Liberty
How does respect for freedom, personal autonomy, or consent apply?
Interface vs Abstract Class
Interface is not a class Class can implement many interfaces but one class
2 approaches for allowing an instance of a class to have multiple types
Interfaces and Inheritance
The use of a generic data type is preferred over using Object as a general class in a collection because
It ensures that all the members of the collection are objects related by inheritance.
Advantage(s) of an inner iterator class over a separate, (non-inner), iterator class:
It has direct access to the ADT's data so it can execute more efficiently
Extensibility
New types can be added later without having to change code that references only the interface or parent class types
Confidentiality Goal
No information leaking
Availability Goal
No interruption of service
Assurance
No lying
Authenticity Goal
No lying
Integrity Goal
No tampering
Anonymity
No tracking
Is the bubble sort useful
No, O(n^2)
Does casting change an object
No, it creates an anonymous reference to an object
In a circular array-based implementation of a queue, what is the efficiency performance of the dequeue operation ?
O(1)
Efficiency of a method that iterates through an array with 2 separate loops
O(n)
For an array implementation of a list, the worst case efficiency of remove(index) is:
O(n)
What is the big-Oh complexity of getEntry(position) on a list that is implemented with a singly linked chain?
O(n)
Sorted List efficiency
O(n) for everything except getEntry(position) which is O(1) for the array sorted list
Casting
Obtains a reference of a different type, but does not change the object
Does an iterative loop or recursive method use more memory?
Recursion
.remove
Removes first node
.remove()
Removes last element in a array
Inorder Tree Traversal
Sorts from left to right
Postorder Tree Traversal
Start with lowest level on left, then right, then work up
Object()
The superclass of every class
What does JVM look at during runtime
The type of the objet to determie which method implementation to call
What is checked at compile time
The variable type to make sure that any methods invoked actually exist
Pre-Order Traversal
Visit root before we visit root's subtrees
Post order traversal
Visit root of a binary tree after visiting nodes in root's subtrees
In-Order Traversal
Visit root of a binary tree between visiting nodes in root's subtrees.
Preorder Tree Traversal
Visiting any given node before visiting its children Start at root, keep going left until there are no left nodes, then go right at lowest point, then keep going up
Outcomes
What achieves the best short- and long-term outcomes for me and all others?
Character
What action best reflects who I am and the person I want to become?
Authority
What do legitimate authorities (e.g. experts, law, my religion/god) expect of me?
Responsibilities
What duties and/or obligations apply?
Rights
What rights (e.g. innate, legal, social) apply?
Empathy
What would I do if I cared deeply about those involved?
For the list, [20, 40, 10, 30], what will the array look like after the second pass of selection sort?
[10, 20, 40, 30]
generic data type
a type for which the operations are defined but the types of the items being manipulated are not enable you to write a placeholder instead of an actual class type
Which of the following List member methods should not be implemented for a SortedList?
add (int newPosition, T newEntry)
Which bag behavior(s) would need to be modified when implementing a set?
add()
Different methods in sorted lists
add() remove(anEntry) getPosition(anEntry) no replace() method
Implementation
all the data fields and details of the method definitions
O(1)
an action is independent of the problem size
A key benefit of inheritance is
an object can have several types, it is type compatible with any of its superclasses
Wrapping around an array queue
backIndex = (backIndex + 1) % queue.length to increment backIndex
Encapsulation
design principle that encloses data and methods within a class, thereby hiding the class' implementation details
Abstraction
focus on what and not how
Dequeueing a full array queue
frontIndex = (frontIndex + 1) % queue.length
Bag Efficiencies
getFrequencyOf - O(n) clear - O(n)
O(n^2)
happens when there is a nested for loop, among other things
To remove a specified entry of a bag that is implemented with a linked chain, first get a reference to the node to remove, then the most efficient approach is to:
move the data in the first node to the referenced node , then remove the first node
compareTo values
negative if this is less than parameter value
The pro(s) of using an array are
o Adding an entry to the bag is fast o Removing an unspecified entry is fast
Pros of using a chain
o Bag can grow and shrink in size as necessary o Remove and recycle nodes that are no longer needed o Adding new entry to end of array or to beginning of chain both relatively simple o Similar for removal
The con(s) of using an array are
o Removing a particular entry requires time to locate the entry o Increasing the size of the array requires time to copy its entries
Cons of using a chain
o Removing specific entry requires search of array or chain o Chain requires more memory than array of same length
Benefit of no node class
o Simplicity o Implement all operations recursively
Which of the following visibility modifiers should be used for a field in a class C if the programmer does not want the subclass D to have direct access to the field?
private
The most efficient approach to dealing with a gap left in an array after removing an entry from a bag is to
replace the entry being removed with the last entry in the array and replace the last entry with null
When too many recursive calls are made, creating more activation records than the allocated program memory can handle, what kind of error/exception occurs?
stack overflow
For an array implementation of a stack, the most efficient choice for the top location is
the last element in the array
If a generic method is declared with type parameter <T extends Comparable<T>> and local variables value and target, both of type T, are given, then the following code can be used within the method:
value.compareTo(target)
Client Interface
what client code needs to know to use a class
Null Pointer Exception
when a program attempts to run a method with a null object Most common exception
Polymorphism
when the type of the instance is determined at runtime
Recursive vs Iterative Search
· Iteration saves time and space · Recursion does not require much additional space for recursive calls · Coding binary search recursively is somewhat easier
generic placeholder
• A generic data type • A type parameter
Tree efficiency
• Add, remove, and getEntry are O(h) for height h • Full and complete trees give O(log n) performance
Why use an iterator
• getEntry(index) can be O(n^2) with a linked chain, but an iterator makes it O(n) • Can traverse all the data in a collection like a bag or set, even without access to indexed elements