CMPS 144   Fall 2022
Final Exam Preview

• Hashing and Hash Tables: (See Lab #14) 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), and be able to compare the latter number with how many probes could be expected to be made in an unsuccessful search, based only upon the table's packing density.
  • show at which address a new <key,value>-pair would be inserted (given its key's home address).
  • show how any <key,value>-pairs would move within the table as a consequence of removing one of them.
• Binary Trees:
  • Huffman Trees/Coding: 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 #14.)
  • 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. Be able to trace execution of the HeapSort algorithm. (See Lab #14.)
  • Binary Search Tree: Given one, show how it would change as a result of inserting or deleting specified keys. (See Lab #13.)

• Recursion: Given a relatively simple recursive method, be able to trace its execution (e.g., by showing the tree depicting all instances of the method that get created (see Lab #11: Array Sum)) and to describe its effect (e.g., what does it print, or what value does it return) when called with specified parameter values.

  Given a relatively simple problem —involving numbers or an array, say— that is amenable to a recursive solution, be able to describe such a solution. (See Lab #11.)

• Lists:
  • 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 #12.) Also, be able to trace execution (manually) of such a method.
  • 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 Lab #10.)

    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 #9.)

• Runtime complexity: Given a code segment involving loops, be able to figure out how many iterations occur (as a function of some measure N of input size) and to characterize that number in terms of "big-Oh" notation (e.g., O(N), O(N²)). (See the "Big-Oh Examples" and "Analysis of Selection and Insertion Sort Algorithms" links on the course web page.)
• Sets: Be able to develop a Java method that makes use of instances of the SetIntRange class (as does the Taxman class of Prog. Assg. #5).
• Parallel computing: With respect to the relevant web page, be able to answer questions about the algorithms shown there (summing the elements of an array, RankSort), or to give a high-level sketch of a parallel algorithm that works in a manner similar to an example shown there.
• Class Hierarchies/Extension
• To provide extra functionality: Given a relatively simple Java class that lacks some desired functionality, develop a child class that provides that functionality. (See Lab #3.)
• To provide alternative behaviors of some key method(s): Given a relatively simple Java class having an abstract method, develop concrete child classes that implement that method in ways that result in different behaviors. (See the Counter Class Hierarchy and Lab #4.)

  A similar effect (of producing objects of the same class having different behaviors) can be achieved by using an instance variable that provides some particular functionality (e.g., comparison, classification) as described in a Java interface (e.g., java.util.Comparator). (See Generic Comparator-based Sorting in Java. Indeed, this is usually a better approach than using extension.

• Stacks, Queues: applications and implementations (array-based and Link1-based)
• 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 #4.)