Transcript Slides
CSC 212 – Data Structures
LECTURE 41:
COURSE REVIEW
Final Exam
Fri., Dec. 17th from 8AM – 10AM in OM 200
Plan on exam taking full 2 hours
If major problem, come talk to me ASAP
Exam covers material from entire semester
Open-book & open-note so bring what you’ve got
My handouts, solutions, & computers are not allowed
Cannot collaborate with a neighbor on the exam
Problems will be in a similar style to 2 midterms
Inheritance
implements & extends used for relationships
Both imply there exists an IS-A relationship
public class Student extends Person {…}
public class Cat extends Mammal { … }
public class AQ<E> implements Queue<E>{…}
Inheritance
All Java classes extend exactly 1 other class
All fields & methods inherited from the superclass
Within subclass, can access non-private members
Private methods inherited, but cannot be accessed
Classes can implement any number of interfaces
Must implement methods from the interface
Overriding & Hiding
Subclass can override/overload inherited methods
Instance’s type determines which method is called
Parameter list stays the same to override the method
Overload method by modifying parameter list
Field in superclass hidden by redeclaring in subclass
2 fields with the same name now in subclass
Use the field for variable’s type
Exceptions in Java
throw an exception when an error detected
Exceptions are objects - need an instance to throw
try executing code & catch errors to handle
try only when you will catch 1 or more exceptions
Do not need to catch every exception
If it is never caught, program will crash
Not a bad thing – had an unfixable error!
Exceptions listed in methods’ throws clause
Uncaught exception only need to be listed
Should list even if thrown by another method
Abstract Methods
Methods declared abstract cannot have body
IOU for subclasses which will eventually define it
abstract methods only in abstract classes
Cannot instantiate an abstract class
But could still have fields & (non-abstract) methods
abstract methods declared by interfaces
Interfaces cannot declare fields
public abstract methods only in interfaces
Arrays vs. Linked Lists
Concrete implementations used to hold data
Not ADTs
Arrays are easier to use & provide quicker access
Also are impossible to grow
Implementing ADTs harder due to lack of flexibility
Slower access & more complex to use linked lists
Implementing ADTs easier with increased flexibility
Can be singly, doubly, or circularly linked
Stack vs. Queue
Order read if Stack
Order read if Queue
Access data with Stack in LIFO order
Last In-First Out is totally unfair (unless always late)
Data accessed in Queue using FIFO order
First In-First Out ensures early bird gets the worm
Simplest ADTs
Queue
Stack
Deque
ADT Operations
DEQUE
QUEUE
STACK
addFront()
addLast()
enqueue()
push()
getFront()
getLast()
front()
top()
removeFront()
removeLast()
dequeue()
pop()
Iterators & Iterables
import java.util.Iterator;
import java.lang.Iterable;
public interface Iterator<E> {
E next() throws NoSuchElementException;
boolean hasNext();
void remove() throws UnsupportedOperationException;
}
public interface Iterable<E> {
Iterator<E> iterator();
}
More Iterator & Iterable
Abstract work in processing with Iterator
Iterable<Integer> myList;
Iterator<Integer> it;
...
for (it = myList.iterator(); it.hasNext(); ) {
Integer i = it.next();
...
}
Process Iterable objects in an even easier way
...
for (Integer i : myList) {
...
}
IndexList & NodeList
Collection which we can access all elements
Add element before an existing one
Return the 3rd element in List
Loop over all elements without removing them
LIST ADTs differ in how they provide access
INDEXLIST uses indices for absolution positioning
Can only use relative positions in NODELIST
All LISTS are ITERABLE
Sequence ADT
Combines DEQUE, INDEXLIST, & POSITIONLIST
Includes all methods defined by these interfaces
Adds 2 methods to convert between systems
Get Position at index using atIndex(i)
indexOf(pos) returns index of a Position
Sequence ADT
Combines DEQUE, INDEXLIST, & POSITIONLIST
Includes all methods defined by these interfaces
Adds 2 methods to convert between systems
Get Position at index using atIndex(i)
indexOf(pos) returns index of a Position
Trees vs. Binary Trees
Both represent parent-child relationships
Both consist of single "root" node & its descendants
Nodes can have at most one parent
Root nodes are orphans -- do not have a parent
All others, the non-root nodes must have parent
Children not required for any node in the tree
No limit to number of children for non-binary trees
2 children for node in binary tree is the maximum
Traversal Methods
Many traversals, differ in order nodes visited
Do parent then do each kid in pre-order traversal
Traversal Methods
Many traversals, differ in order nodes visited
Do parent then do each kid in pre-order traversal
Post-order traversal does kids before doing parents
Traversal Methods
Many traversals, differ in order nodes visited
Do parent then do each kid in pre-order traversal
Post-order traversal does kids before doing parents
Do left kid, parent, then right kid in in-order traversal
Visualization of Tree
Tree
root
size6
Tree
B
B
D
A
C
F
A
D
F
E
C
E
Picturing Linked BinaryTree
BinaryTree
root
BinaryTree
size4
B
A
B
C
D
A
C
D
Priority Queue ADT
Priority queue uses strict ordering of data
Values assigned priority when added to the queue
Priorities used to process in completely biased order
First you get the sugar,
then you get the power,
then you get the women
Priority Queue ADT
PriorityQueue yet another Collection
Prioritize each datum contained in the collection
PQ is organized from lowest to highest priority
Access smallest priority only sort of like Queue
min() & removeMin() return priority & value
Implementation not defined: this is still an ADT
Remember that organization & order is theoretical only
Priority Queue ADT
order is theoretical only
Entrys in a PriorityQueue
PriorityQueues use Entry to hold data
As with Position, implementations may differ
Entry has 2 items that define how it gets used
PQ will only use key – the priority given to the Entry
Value is important data to be processed by program
Sequence-based Priority Queue
Simplest implementation of a Priority Queue
Instance of Sequence used to store Entrys
Many implementations possible for Sequence
But we already know how to do that, so…
Assume O(1) access and ignore all other details
But how to store Entrys in the Sequence?
Order Entrys by priority within the Sequence
-OR Sequence unordered & searched when needed
Heaps
Binary-tree based PQ implementation
Still structured using parent-child relationship
At most 2 children & 1 parent for each node in tree
Heaps must also satisfy 2 additional properties
Parent at least as important as its children
Structure must form a complete binary tree
2
5
7
9
6
Hints for Studying
Will NOT require memorizing:
ADT’s methods
Node implementations
Big-Oh time proofs
(Memorizing anything)
Hints for Studying
You should know (& be ready to look up):
How ADT implementations work (tracing & more)
For each method what it does & what it returns
Where & why each ADT would be used
For each ADT implementations, its pros & cons
How to compute big-Oh time complexity
Studying For the Exam
1.
What does the ADT do?
2.
How is the ADT used?
3.
Where in the real-world is this found?
What are the applications of this ADT?
How is it used and why?
How do we implement the ADT?
Given the implementation, why do we do it like that?
What tradeoffs does this implementation make?
“Subtle” Hint
Final Exam Schedule
Lab Mastery Exam is:
Tues., Dec. 14th from 2:45PM – 3:45PM in OM 119
Final Exam is:
Fri., Dec. 17th from 8AM – 10AM in OM 200