In general, students find problems that require them to trace, write, and unscramble code, or to complete code fragments to be the most difficult. A good way to practice for such questions is to:

• learn what the terminology is and what each term means, to be sure that you can understand each question
• learn any assumptions or pre-conditions that are required before a given algorithm is the correct choice
• develop good techniques and strategies for tracing code quickly and effectively
• practice tracing recursive vs iterative code until you have an effective technique for tracking details of either style
• write code for all of the data structure operations
• practice all algorithms until you do not need to look up the algorithm to execute each step
• think of your own similar but different problems as were done in lecture and notes and solve them
• practice the lookup and insert operations for each data structure variation until you can do them without looking them up in your notes
• make sure that you can remove from a BST and Hash Table and graph.
• form a study group with your classmates and interview each other - think of questions to ask each other to solve and vice versa
• challenge each other
• think of the problem, data structure, or algorithm that you most hope I do not ask about and learn how to solve that problem until you hope I ask that question
• repeat the previous step for all problems and topics that scare you most

• Lectures
• Readings: Modules 1-6 (up through Hashing and Hash Tables
• Assignments: H1-H5, P1-P3 (up through HashTable: constructor,put(insert),get(lookup))

• Command Line Linux (UNIX): navigating file system (pwd,ls,cat,diff,grep,echo,tree), creating, moving, removing files and directories (cp,mkdir,rmdir), compiling and running Java programs (javac, java, jar), redirecting output to a file (>),
• Testing: Black-box testing, White-box testing, Unit testing, JUnit tests, how to test that exceptions are thrown as expected
• Team Building: Stages of team development, team roles, team rules, ice-breakers, communication and conflict resolution strategies
• Version Control: Git commands (init, log, status, clone, add, commit, diff, pull, push), GitHub
• Balanced Search Trees
  • all trees: traversals: pre-order, in-order, post-order, and level-order.
  • binary search trees (BSTs), key value, implementing BSTs, algorithms for BST operations (print, lookup, insert, delete), in-order successor, in-order predecessor, complexities of BST operations, balanced search tree terminology
  • AVL Trees: algorithms for operations (print, lookup, insert, delete)
  • Red-black tree: red-black tree properties, root property, red property, black property, algorithms for red-black tree operations (print, lookup, insert, delete (for all cases except from black leaf node)
  • B-Trees: branching factor, k-ary trees, BTree nodes, 3-Nodes, 4-Nodes, B-Tree algorithms for operations (print, lookup, insert, delete)
• Hashing: hashing terminology: key, hash function, Java's hashCode() vs hash index, hash table, load factor, collision, ideal hashing; hash table operations (algorithms & complexities); choosing table size; defining a good hash function, hashing techniques: mod by table size, folding, extraction, weighting, exclusive-OR, bit-shifting, handling non-integer keys using Java's hashCode(); collision handling strategies: open addressing (linear & quadratic probing, double hashing) and buckets (fixed-sized arrays, linked-lists, balanced search trees)

You are responsible for material covered in:

• Midterm exam topics
  The final is cumulative although there will be more emphasis on the topics covered since midterm. We try for about 3/4 on new material and 1/4 on earlier topics.

• Lectures: Weeks 1-14 (focus on weeks 7-14)
• Readings: Weeks 1-14 (focus on weeks 7-14)
• Homeworks: Quizzes (focus on quizzes 4-9 and practice)
• Assignments: all individual and team programs, (focus on p3-p4, Final Project)

Topics List:

• Command Line Development Tools (UNIX/Linux): shell scripts, vim, project management: zip and unzip files, using make, executable.jar files
• Graphs: graph terminology: node, vertex, edge, size (#edges), order (#vertices), directed, undirected, source, target, adjacent, successor, predecessor, degree, in-degree, out-degree, path; classifying different kinds of graphs: cyclic, acyclic, complete, connected, weakly-/strongly-connected, connected component, weighted, DAG (Directed Acyclic Graph); graph ADT (implementations & complexities), representing edges: adjacency lists, adjacency matrix; traversals, spanning trees (DFS, BFS, Prim's MST, Kruskal's MST), finding paths & cycles, Dijkstra's algorithm, topological ordering
• Sets:
  notation: ∆ ∈ ∉ ∖ ∩ ∪ ⊂ ⊃ ⊄ ⊅ ⊆ ⊇ ⊈ ⊉ ' (as in A')
  terms: is a member of, subset, superset, power set
  operations: complement, intersection, union, difference, symmetric difference
  implementation via: array, list, tree, hash table
  able to determine complexity analysis of operations when given implementation details
• Sorting algorithms: O(N) sorts, radix sort, flash sort
• Diagrams: interpret and draw: UML style Class Diagrams, Instance (Object) Diagrams, Memory Model, Data Structures
• Makefile: how to define rules for compile/run Java applications, able to use make utility
• Java Enumerations: create and use
• Java interfaces: abstract methods, static fields and methods, default methods
• Java 8: functional interfaces, anonymous inner classes, lambda expressions, streams and stream operations (.stream(), .filter(Predicate), .map(Function), .collect(toList))
• Java FX and basic GUI design: know how to create and use: user interface controls (Label, TextField, Button, ScrollBar, ScrollPane); layout containers (Border,HBox,VBox,Grid), Scene (set), Stage (show/hide); Events and add event handlers;
• Basic HTML/CSS/JS: correctly use common html tags (html,head,body,p,a,img,ol,ul,dl,table), css styles (class vs id), JavaScript (var, function, if, for, return)