182 review 1. Course Goals

Transcription

1 Course Goals 182 review 1 More experience solving problems w/ algorithms and programs minimize static methods use: main( ) use and overload constructors multiple class designs and programming solutions documentation: reports, comments / Javadoc Learn and gain experience with dynamic ADTs Linked List, Binary Search Tree, Stack, Queue Learn and gain experience with generic types ArrayList<E>, BSTree<E>, BSTNode<E>, Deque<E>, ArrayDeque<E> Implement Comparable<E> Learn and gain experience with formal and experimental algorithm analysis Big O What else did you gain from this lectures and assignments in this class?

2 ADT Abstract Data Type 182 review 2 For collections, use with generics class = Attributes (variables, nouns) + Behaviors (methods, verbs) inheritance (is-a, can use), reuse of type, # protected accessibility Java has single inheritance of classes abstract (can-have), reuse of type, can't instantiate composition( has-a), use of type enum reuse w/ composition symbolic constants, interface must-have, must-use: constants, enums, abstract methods collections of interfaces restriction of implementor's functionality specific interfaces used with multi-implementor classes java has multiple implmentations (behaviorial inheritance) generics declare collections w/ actual types specified at instantiation implementation of Comparable: int compareto(e other)

3 Assertions, invariants Recursive Problems 3 Invariant: statement about "condition" or "state" that is always true at a position in an algorithm, or for all the algorithm. 1. Must represent the correctness of the algorithm 2. Must be true initially 3. Statements must preserve (! violate) the invariant 4. Must be true at completion (algorithm must halt) Assertion: statement about "condition" or "state" at a position in an algorithm. Assertions can enforce invariants. Assertions can be written into a program and tested at run-time. Java's assert statement If statements: language has no assert Recursive problem patterns: Backtracking and formal grammars

4 Recursion 182 review 4 Recursion occurs when a method calls itself (BST inoder traversal) Recursive algorithms: divide and conquer halting state recursive step solves part of the problem and makes recursive call to solve more when recursion is done; no endless loop of method calls Recursive grammars can be written given a set of rules: x y xy <word> means either x or y means x followed by y, xy means any instance of word is defined <S> = <L> <S> <S> <D> <L> = A B <D> = 1 2 Valid strings? "A12" "AB2"

5 UML Diagrams inheritance is a super factoring inheritance is a super factoring Abstract Class AncestorClass DescendantClass * 1 composition has a array, collections must override inherited abstract methods ClassName - privatevariable : type # protectedvariable : type + publicvariable : type 182 review 5 ApplicationClass + Constructor(arguments) - privatemethod(args) : type # protectedmethod(args) : type + publicmethod(args) : type

6 Linked List UML 182 review 6 A singly linked list ADT allocates space as needed has 1 "head" SLList<SLNode> has 0 or many "nodes" SLLNode<E> alist size is 4 next is b b 20 m m 43 h h 46 c c 87 null

7 3 insertion and 4 deletion cases 182 review 7 create SLLNode SLLNode newnode new SLLNode(E) 1. insert at "front" of list, 2. insert within in the list 3. insert at the end of the list Deletion 1. remove from empty list SSList.next == null, return null 2. remove "front" of list, traverse list looking for target, stop when found, or end of list 3. remove from list 4. target "e" not in list

8 BSTree UML root 182 review 8 Element is an example class type for <E>

9 traversal left element BSTNode { Integer key BSTNode right, left; BSTNode(Integer k){ key = k right = null left = null } Integer get() { return key } int compareto(...) {...}; } right b 11 null null v 17 BSTNode root; // n... inorder(bstnode n) { // iterator if (n == null) return; inorder(n.left) visit() // print? inorder(n.right) } b g g 23 null root null n 32 v e u 38 null 182 review 9 e 41 u null w w 42 null null Write w/ generics <Element> Change order of go left visit go right

10 deletednode BSTNode delete(bstnode target) find target, mark for replacement, find immediate successor (replacement), replace, delete replacement (always a leaf). Insertions and Deletions Assumes no duplicate Elements allowed in BST 182 review 10 All insertions are on leafs All insertions result in binary search tree void insert (BSTNode newnode) 1. Empty tree 2. Non-empty tree Deletion All "actual deletions" are at leafs All deletions result in valid binary search tree

11 Stack UML 182 review 11 Operations on a stack are: Stack<E>() <E> top() push(<e>) <E> pop() boolean isempty() create a new Stack that can hold E values return a reference to the top of the stack, "peek" at the stack put an E on top of the stack, top references E remove an E from the top of the stack, top has a new reference returns true if stack has no E values else false

12 Queue UML 182 review 12 t c 4 t b m b Operations: enqueue or addlast dequeue or removefirst 20 c 5 m 40 b 33 null

13 Array based implementation 182 review 13 Consider a statically allocated (fixed size) array Queue having a: count, front, and rear int variables. Count is the size of the Queue, front and rear are indexes (subscripts) into the array. The front of the Queue is not always at index 0. As items arrive to the non-empty queue they are inserted into position (rear + 1) % capacity As items depart from the queue the value of front must be incremented front (front + 1) % capacity Stacks also have array based implementations. Circular Queue 4 count 2 front rear

14 JFC Deque as a Queue or Stack 182 review 14 Queue Method add(e) offer(e) remove() poll() element() peek() Stack Method push(e) pop() peek() Equivalent Deque Method addlast(e) offerlast(e) removefirst() pollfirst() getfirst() peekfirst() Equivalent Deque Method addfirst(e) removefirst() peekfirst() Deque<E> aqueue = new LinkedList<E>(); aqueue is-a LinkedList object that can only be accessed with Deque's interface methods.

15 Applications 182 review 15 Linked List Small linear search, or static / ordered collections: binary search dynamically sized collections Vs ArrayList<E> Binary Tree Large dynamically updated search collections Huffman coding, frequency based Expression trees: infix postfix, prefix Heaps, implemented ArrayList tree, JCF Priority Queue, min heap Stacks Expression evaluation Implementation of method calls (recursive algo w/o recursion) Queues Transmission (communication) buffers computer i/o stream: keyboard, hard disk, internet packets digital media: streaming media audio, video simulation: next event lists

16 Big review 16 Big O is "on order" analysis, efficiency of algorithms estimate, statement of algorithms efficiency growth rate Time && Memory fn(critical operations, frequency of operations) O(...) simplification of fn(critical operation, frequency of operation) remove constants, assume critical operation(s) are constant ignore constants O(n) O(n -1) ignore low order terms O(n 3 ) O(n 3 + n 2 + n) ignore multiplicative constants O(n 2 ) O(7 * n 2 ) combine growth rates O(n 2 + n) O(n 2 ) + O(n)

17 Big 0 values 182 review 17 fastest O(1) constant index into an array, hash functions, pop/push stack, add/remove queue O(n) linear search unsorted array or linked list array, list, or BST traversal O(n 2 ) quadratic simple sorts: exchange, selection 2 nested loops; n items O(log n) logarithmic Binary search in a sorted list BST insert, find, Heap insert, remove O(n log n) "n log n" merge, quicksort O(a n ) exponential tower of Hanoi, recursive fibonacci, slowest where a > 1 permutations

18 algorithm evaluation 182 review 18 formal Big O, for initial design considerations experimental measure representative cases (probabilistic variations), for time / space measurements: performance system software metrics KLOC (thousands lines of code) complexity measures (graphs,...), for maintenance / modification, understandability qualitative code review / walkthroughs for maintenance / modification, understandability Size of problem determines degree of algorithm evaluation required.

19 P1, P2, P3 182 review 19 P1 Simulate Market ArrayList<E> Generic type UML class diagrams simulation P2 Binary Tree Experiment, experience with BST BinaryTree, BinaryTreeNode class design, implementation, testing Big 0, O log n expectations for BST Experimental measuring of algorithm performance BST max and average levels, time P3 Curious and Hungry Robot Interfaces and JCF Deque <E> memory = new ArrayDeque<E>(); Application design and states

20 Application as state transistion 182 review 20 die has energy? E <= 0 start E <= ½ size has recall? consume no detection move detect? E > ½ size move retrieve no recall yes recall detection learn State diagrams can help understand / design problem

21 Generics and Interfaces 182 review 21 Interfaces can be used to: restrict the behaviors (method implementation) of implementing classes (LinkedList<E> implements Deque<E> interface) Deque <E> memory = new LinkedList<E>(); provide collection membership based on behavior (common method) ArrayList<Drawable> scene; // Drawable requires-a draw() Generic <E extends InterfaceADT> Allows compiler to test method signatures of implemented (shared) methods without specifying actual generic class.

22 What to do next? 182 review 22 More algorithm design / implementation, ADTs, Comp 282: hashing: map functions, map classes: JCF HashMap, HashSet Self balancing search trees: AVL, 2,3 trees, red-black, B-Tree JCF TreeMap, TreeSet graphs: {nodes, edges} adjacency, search, path finding multi-access collections: primary key access, non-key access databases: design / normalization, query SQL Grammars and languages Comp 310, 333 Software Engineering: design, verification, validation Comp 380 Algorithms complexity and analysis Comp 482 Collection libraries, other APIs Microsoft's.NET C++ STL (Standard Template Library)