Lecture 41: Course Review

CSC 212 – Data Structures Lecture 41:Course Review

Final Exam • Tues., Dec. 10thfrom 8:00 – 10:ooAM in OM220 • 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

Classes vs. Objects • Classes are blueprints describing data type • By itself, class only used for staticfields & methods • Objects are instances of a class • New objects created (instantiated) using new • Fields describe state of an object • Object’s behavior represented by methods

static v. Instance-based • Methods that are instance-based have this • Aliased to instance on which method called • Can directly use fields & call methods in class • No thisparameter in staticmethods • Code directlyusing instance-based members illegal… • … using staticfields & methods perfectly legal • As always, can use object to access its members • Call staticmethods via class if protection allows

Abstract Methods • Methods declared abstractcannot have body • IOU for subclasses which will eventually define it • abstractmethods only in abstract classes • Cannot instantiate an abstract class • But could still have fields & (non-abstract) methods • abstractmethods declared by interfaces • Interfaces cannot declare fields • public abstract methods only in interfaces

Interfaces • Can only declare important constant fields • publicstaticfinalmust be used for fields • Interface declares publicabstractmethods • Methods must be defined by classes implementing it • But method’s body cannot be defined in interface

Interfaces CANNOT INSTANTIATE AN INTERFACE • Only classes can be instantiated

Inheritance • implements& extendsused for relationships • Both imply there exists anis-arelationship 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’stype determines which method is called • Parameter list stays the same to override the method • Overload method by modifying parameter list

Exceptions in Java • throw an exception when an error detected • Exceptions are objects - need an instance to throw • try executing code & catcherrors to handle • try only when you will catch 1 or more exceptions • Do not need to catchevery exception • If it is never caught, program will crash • Not a bad thing– had an unfixable error! • Exceptions listed in methods’ throwsclause • Uncaught exception only need to be listed • Should list even if thrown by another method

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 • Access data with Stackin 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 Order read if Stack Order read if Queue

Simplest ADTs

Initial ADTs’ Operations

Iterators & Iterables import java.util.Iterator;import java.lang.Iterable;public interface Iterator<E> {Enext() throws NoSuchElementException;booleanhasNext(); voidremove()throws UnsupportedOperationException;}public interface Iterable<E> {Iterator<E> iterator();}

Iterable v. Iterator • Iterable class is/has data we want to use • Declaring it Iterablepromises generic way to access • Does not do any work, but provides object doing work • While has access, Iterator(usually) separate class • Iterator instance returns values in other class/array • Always (almost) includes field with reference to data holder • Field (cursor) tracks next location in data to be returned

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) {...}

List’s Operations

List Subinterfaces Defined public interface OrderedList<T> extends List<T> { public void add(T element);} public interface UnorderedList<T> extends List<T> { public void addToFront(T element); public void addToRear(Telement); public void addAfter(Telem, Ttgt); }

List Key Idea Lists are Iterable

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

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 • Really, really, really simple to record what is done • Follow simple algorithm to see how it works

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 • Really, really, really simple to record what is done • Follow simple algorithm to see how it works • Took CSC212 before you were born & I need to trace it

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 • Really, really, really simple to record what is done • Follow simple algorithm to see how it works • Took CSC212 before you were born & I need to trace it • Pro tip: Just $#&*@ trace it on paper

D C B A Picturing LinkedBinaryTree B A C      D

Priority Queue ADT • Priority queue uses strict ordering of data • Elements assigned priority when added to 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 • find() & remove()return element • Implementation not defined: this is still an ADT • Remember that organization & order is theoretical only

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 order is theoretical only

Heaps • Binary-tree based PQimplementation • 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 9 7 6

Hints for Studying • Will NOTrequire memorizing: • ADT’s methods • Nodeimplementations • 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-Ohtime complexity

Studying For the Exam • What does the ADT do? • Where in the real-world is this found? • How is the ADT used? • 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 tradeoffsdoes this implementation make?

“Subtle” Hint Do NOT bother with memorization Be ready to lookup &use information quickly

Final Exam Schedule • Final Exam is: Tues., Dec. 10thfrom 8:00 – 10:ooAM in OM220 • Lab Mastery Exam is:Fri., Dec. 13thfrom 2:45 – 3:45PM in SH1008

Lecture 41: Course Review