CMPS 144   Spring 2020
Final Exam Preview

• Hashing and Hash Tables: Given a hash table (where open addressing is used with the linear probing collision resolution strategy),
  • compute the expected number of probes in both successful and unsuccessful searches (for that specific table).
  • show at which address a new <key,value>-pair would be inserted (given its key's home address).
• Parallel computing: With respect to the relevant web page, be able to answer questions about the algorithms shown there, or to describe a parallel algorithm that works in a manner similar to an example shown there.
• Binary Trees:
  • Recursive Paradigm: Be able to develop a recursive method that computes the height of a binary tree, or something like that, using the methods of the recursive paradigm.
  • Binary Search Tree: Given one, show how it would change as a result of inserting or deleting specified keys. (See Lab #10.)
  • Huffman Trees: Given a list of symbols and their respective frequencies-of-occurrence, build a corresponding Huffman Tree and show the symbol-to-codeword mapping that the tree induces. (See Lab #11.)
  • Heaps: Interpreting an array as representing a complete binary tree, show steps involved in "heapifying" it, so as to turn it into a min- or max-heap, or in preserving its heapness in the face of removing the item from its root. (See Quiz #3.)
• Minimum Spanning Trees: Given an undirected graph with edge weights, show the minimum spanning tree that Prim's algorithm would produce if applied to that graph. Be able to show the values of vital variables (e.g., closest[]) at snapshots in time. (See Lab #11.)
• Lists:
  • Positional Paradigm: Given a concrete array-based representation of a positional list with cursors, show how the instance variables would change as a result of inserting or removing an item. (See Quiz #2.)

    Or, given a relatively simple problem about lists, develop a Java method that uses the methods in the PositionalListWithCursors and PositionalListCursor interfaces to solve it. (See Lab #8.)

  • Recursive Paradigm: Be able to develop a recursive Java method that solves a relatively simple problem (e.g., count how many negative numbers are in a list of integers). (See Lab #9.)
• Sets: Be able to develop a Java method that makes use of instances of the SetOfInt class (as did the Taxman class of Prog. Assg. #4).
• Stacks and Queues: Be able to use methods that insert and remove items to solve a problem.
• Recursion: Given a relatively simple recursive method, be able to describe its behavior (e.g., what does it print, or what value does it return) when called with specified parameter values.
• Runtime Analysis: Given code segments involving (probably nested) loops, determine the number of iterations as a function of some natural number N describing input size and characterize that number using Big-O notation (e.g., O(n²)).
• Loop Invariants: Given some task to carry out, and a loop invariant to guide you, develop code to solve the problem in a manner consistent with the given loop invariant. (Remember the 2- and 3-color partitioning problems?) (See Lab #2.)
• Arrays: Given a task to be performed on an array, write Java code that does it. (E.g., count the number of inversions, i.e., pairs of elements such that the lesser is in a smaller-numbered location than the larger.)
• Class Hierarchy: Given a relatively simple Java class that lacks some desired functionality, develop a child class that provides that functionality. (See the Counter Class Hierarchy and Labs #3 and #5.)