1. Announcements Review problems Review Outline

2. Online Survey http://www.coursesurvey.gatech.edu

3. Java vs. Pseudocode Problems will be labeled with requirements –Java –Pseudcode Focus is not on syntax

4. Taking the Final Read.announce Travel light Don’t be late No calculators, cell phones, laptops, implants, neural networks, etc. Use pencil (bring an eraser!) Look over test before starting Ask questions Pace yourself/Spend 1/n th of the time on a question Do easier questions first

5. Review Problems What is the Big O? i <- N j <- 1 loop exitif(i <= 0) loop exitif(j > M) j <- j + 1 endloop i <- i - 1 endloop

6. Review problems Circle and Identify the 3 parts of recursion: Function Fact returnsa Num(N iot in Num) if(N = 0) then Fact returns 1 else Fact returns N * Fact(N - 1) endif endfunction // Fact

7. Review problems Circle and Identify the 3 parts of recursion: Function Fact returnsa Num(N iot in Num) if(N = 0) then Fact returns 1 else Fact returns N * Fact(N - 1) endif endfunction // Fact Check for termination Call self Move one step closer

8. Review Problems Recall that a leaf is a node in a binary tree with no children. Write a module that when passed a pointer to a binary tree will return the number of leaves. The module should use recursion

9. Leaves Function Leaves returnsa Num (current iot Ptr toa TNode) if(current = NIL) then Leaves returns 0 elseif(current^.left = NIL AND current^.right = NIL) then Leaves returns 1 else Leaves returns Leaves(current^.right) + Leaves(current^.left) endif endfunction // Leaves

10. Review Problems Write a module to convert an unsorted linked list to a sorted linked list. Use data structure conversion as opposed to a sort algorithm such as Bubble Sort or Merge Sort

11. Solution Recall that for this type problem you will typically need three modules: –A standard linked list AddInOrder module –A modified linked list traversal module modified to keep track of pointer to new list –A startup module

12. Review problems Algorithm Pain a,b,c iot Char a <- ‘b’ b <- ‘c’ c <- ‘a’ Agony(c,a,’b’) print(a,c,b) b <- funky(a,c) print(a,b,c) endalgorithm Procedure Agony(a iot in/out Char, b iot out Char, c iot in Char) t iot Char if(c = ‘c’) then c <- ‘d’ t <- b b <- a a <- t else b <- a a <- ‘b’ endif endprocedure Function funky returnsa Char (x,y isoftype in Char) if(x = y) then funky returns ‘a’ else funky returns ‘b’ endif endfunction

13. Review problems Write a vector class It should be generic and support (at least) the following methods in the public section AddToEnd AddAt(nth) Remove(nth) Size Get(nth)

14. class Node { Object data; Node next; public Node(Object data) { this.data = data; next = null; }

15. class Vector { private Node head; int count; public Vector() { head = null; count = 0; } public int size() { return count; }

16. public void addToEnd(Object datain) { if(head == null) { head = new Node(datain); count++; } else { addToEnd (head, datain); }

17. private void addToEnd(Node cur, Object datain) { if(cur.next == null) { cur.next = new Node(datain); count++; } else { addToEnd(cur.next, datain); }

18. public void addAt(int nth, Object datain) // First element is numbered 0 if(head == null || nth == 0) { Node temp = new Node(datain); temp.next = head; head = temp; count++; } else { addAt(head, nth, datain, 1); }

19. private void addAt(Node cur, int nth, Object datain, int position) { if(cur.next == null || nth == position) { Node temp = new Node(datain); temp.next = cur.next; cur.next = temp; count++; } else { addAt(cur.next, nth, datain, position + 1); } )

20. public void remove(int nth) { if(head != null) { if(nth == 0) { head == head.next; count--; } else { remove(head, nth, 1); } } // remove

21. private void remove(Node cur, int nth, int position) { if(cur.next != null) { if(nth == position) { cur.next = cur.next.next; count--; } else { remove(cur.next, nth, position + 1); }

22. public Object get(int nth) { return get(head, nth, 0); } private Object get(Node cur, int nth, int pos) { if(cur == null) { return null; } else if(nth == pos) { return cur.data; } else { return get(cur.next, nth, pos + 1); } } // Vector

23. Questions?

24. Review The Algorithmic Model –Algorithm defined –Properties of good algorithms –How to describe algorithms –Relating problems to algorithms to programs (hierarchy needed)

25. Review View of programming languages/algorithms –Data vs. instructions –Built-in vs. user-defined –Complex vs. atomic Data –Type vs. variable (Declaration and Initialization of variables) –The 4 atomic built-in types (Num, Characters, Booleans, Pointers) –The complex built in type String

26. Review Operations –Assignment –Arithmetic +, -, x, /, div, mod Precedence rules Using parenthesis to modify precedence –Input and output Print Read

27. Review Conditionals –Purpose & defined –Relational operators (, =, <>, >=, <=) –Boolean operators (AND, OR, NOT) –Boolean expressions (Simple & Complex) –Control flow of the if-then-else statement –Elseif as shorthand Writing an algorithm (how to begin)

28. Review Program maintenance Software Engineering facts about program cost Documentation Benefits of Constants

29. Review Procedural Abstraction Why modularity (Benefits) Need for interface Scope of variables Contract (Pre, post, and purpose statements for every module) Information flow – in, out, in/out Parameters intro (In, out, in/out) Types of modules

30. Review Procedure Rules when to use a procedure Declaration Function Rules when to use a function Declaration Returning values via the “returns”

31. Review Module invocation Parameters Formal vs. actual Parameter matching How parameters work (In, Out, & In/out) Tracing Activation stack Frames Rules of parameter matching (In, Out, & In/out) Examples

32. Review Recursion (Intro) Purpose – repetition Characteristics – calls itself, terminating condition, move closer 2 forms – final action or not Examples Tracing recursive modules Recursion (Advanced) Mutual recursion Design by Contract

33. Review Data Abstraction –Records Declaring records Creating variables of record type Accessing fields of a record variable (the ‘.’ operator) Avoid anonymous types Combining records (records inside records)

34. Review Static vs. dynamic memory/data Pointers Simple example of ptr toa num Following the pointer via the ‘^’ operator Dynamic data structures Linked Lists Defined/properties Proper Record declaration Accessing information in a linked list via pointers

35. Review Linked Lists (continued) –Adding nodes –Simple – no recursion (To front) –Insertion recursive method –To end –In middle (when sorted) –Deleting nodes Simple - no recursion (From front) Deletion recursive method

36. Review Stack –Defined/properties –Push –Pop –Tracing changes (example of algorithm using push & pop)

37. Review Queue Defined/properties Enqueue Dequeue Tracing changes (example of algorithm using enqueue and dequeue) Trees Defined/properties Binary trees (Record declaration) Binary search trees

38. Review Trees (Continued) Recursive insertion in BST Deleting from BST (conceptually) Graphs Defined/properties Record definition

39. Review Static data structures Arrays Defined Need of constants Accessing elements via the index Multi-dimensional arrays (Declaring and accessing)

40. Review Iteration Defined, use for repetition How looping works Loop Endloop Exitif Combined types Examples – array of lists, list of array, tree of lists, etc.

41. Review Methods of Accessing Data Structures Traversal Lists Recursive on lists Iterative on lists Trees In-order Pre-order Post-order Miscellaneous Traversals (Right before Left)

42. Review Breadth-first vs. depth- first Arrays Iterative on arrays Recursive on arrays Search Linear Recursive on lists Traversal-search on binary tree (not BST) Linear, iterative search on array

43. Review Binary, recursive search on BST Binary, iterative search on sorted array Sort Bubble sort Merge sort

44. Review Conversion Defined Helper module advantages List to Tree Array to List Tree to List

45. Review (Java/OO) Syntax –Operators –Operator overloading –Assignment statements –Control structures if else case –Iterative structures while do while for Data Types –Primitives –References class attribute –access modifiers public/private –static –final/constants –initialization

46. Review (Java OO) constructors –access modifiers –default –chaining –overloading methods –access modifiers public/private –static –return type/void –main method –accessors –modifiers –overloading

47. Review (Java OO) object/instance Inheritance –Redefinition (Overriding) –Extension –super class –subclass –abstract Polymorphism Compilation –reference type checking –method checking –Type mismatch checking Run Time –interpreting –dynamic binding –Java virtual machine

48. Review Algorithm Cost and Complexity Measuring performance (space & time) Measuring work (counting instructions) Best, worst, average Measuring work growth O() notation Complex O() rules (drop constants, keep dominant term, etc.)

49. Review Analysis –Linear vs. binary search –Traversals –Data structures Compare on traversals, search, & insert –Bubblesort vs. mergesort Exponential growth –Hanoi, Monkey tiling, wise peasant Reasonable vs. unreasonable

50. Feedback What did you like about the course?

51. Feedback What did you dislike about the course?

52. Feedback What would you differently?

53. Questions?

54. Thanks for taking CS1311! Good luck on Finals.