Chapter Five -- Recursion as a Problem-Solving Technique

- Be able to explain what backtracking and recursion are.

- Be able to understand simple grammars like those described in the
chapter. Be able to construct simple grammars.

- Understand what prefix, postfix, and infix expressions are and know
grammar rules for such expressions.

- Be able to answer questions about how to implement a recursive grammar
checker like the example grammar checkers for C identifiers, palindromes,
or prefix expressions.

- Be able to describe recursive algorithms for solving some simple
problems. Be able to identify the base case(s) and recursive step(s) in
simple recursive algorithms.

- Work [?] study questions that appear in the reading assignments

Chapter Ten and Eleven -- Algorithm Efficiency and Sorting

- Understand the role of operation counts in measuring the work
done by an algorithm.

- Know the definition of the order of an algorithm -- the big-O of the
algorithm.

- Understand the importance of big-O analysis as a comparative measure
of growth-rate functions of algorithms. Understand the way that
common big-O rates are ordered: O(1) < O(logN) < O(N) < O(NlogN) <
O(N
^{2}) < O(N^{3}) < O(2^{N}).

- Know properties of growth rate functions such as O(5*N
^{2}) + O(N) = O(N^{2})

- Know the following sorting algorithms and be able to discuss
their orders appropriately: Selection Sort, Bubble Sort,
Insertion Sort, Mergesort, Quicksort, and Radixsort.

- Work [?] study questions that appear in the reading assignments

C++ Interlude 4 -- Class Relationships and Reuse

- Be able to explain the relationship between a base class and a class
that has been derived through public inheritance.

- Understand how to implement "is-a," "has-a," and "as-a" relationships
among classes.

- Understand what class templates are. Be able to recognize and use
them. Understand the advantage of using class templates.

- Know what overloaded operators are and their advantages. Know about
how the
**operator**keyword is used when making the function prototype for an overloaded operator.

Chapter Fifteen and Sixteen -- Trees

- Know the definitions of all the concepts in the chapter related to tree
anatomy: node, edge, parent, child, sibling, root, leaf, ancestor,
descendant, subtree, height, level, full, complete, balanced, and so
forth.

- Understand preorder, inorder, and postorder traversal. Know algorithms
for implementing these traversals on a binary tree. Given a diagram of a
tree, be able to list the keys in the nodes in any of these traversal
orders.

- Know the definition of
*binary search tree*. Understand the algorithms for doing search, insertion, and deletion in a binary search tree. Given a diagram of a binary search tree, be able to draw another diagram showing how the tree would look if a given element were inserted or deleted by the algorithms described in our text.

- Understand how the efficiency of binary search tree operations depends on the shape of the tree.

Chapter Seventeen -- Heaps

- Know how to define a heap. Know how to implement a heap with the array
implementation described in the text. Understand how insertion and
deletion are performed in this implementation.

- Know how heapsort works -- how it transforms a randomly ordered array
into a heap, and how it then uses the heap deletion operation to sort the
array.

- Know what the "basic operations" are that "define the ADT priority queue"
Understand what these operations do well enough to
write specifications for them.

- Understand how to implement a priority queue using a heap.
Understand the advantages of the heap implementation.

Chapter Eighteen -- Dictionaries and Their Implementations

- Know the definition of hashing. Know the advantages and
disadvantages of hashing relative to other implementations of the
ADT table.

- Know what a hash function is. Know what a perfect hash function is.
Know the two properties that a good hash function must have. Know
several examples of hash functions.

- Understand the need for collision resolution. Know the definitions of
open addressing and separate chaining and understand how to implement
these forms of collision resolution.

- Understand the following terms: linear probing, primary and secondary
clustering, quadratic hashing, double hashing. Understand why it is
desirable to make the size of a hash table a prime or an integer without
any small divisors.

- Know the definition of "load factor" and know the range of load factors
that are well-supported by open addressing and separate chaining.

Chapter Nineteen -- Balanced Search Trees

- Be able to define 2-3 tree, 2-3-4 tree, red-black tree, and AVL tree.

- Know how to conduct a search by key in any of the structures
named above.

- If I give you a sketch of a 2-3 tree or 2-3-4 tree and tell you
to insert and/or delete some keys, you should be able to
accurately sketch how the tree will look after each operation is
carried out.

Chapter Twenty -- Graphs

- Know definitions of graph-related terms such as: graph, vertex, edge,
subgraph, path, cycle, multigraph, connected graph, and directed graph.

- Know the basic operations that would be incorporated into the definition
of a graph as an ADT. Understand what these operations do well enough to
write specifications for them.

- Understand how to represent a graph and implement its operations either
with an adjacency matrix or an adjacency list. Be able to discuss the
relative efficiencies of the operations depending on how they are
implemented.

- Remember and understand the algorithms for depth first search, breadth
first search, topological sorting, and finding a minimal cost spanning
tree.