### CS 3100 Exam Study Guide

You will find all my more recent study questions below. You may want to dig around in my 1997 material and my 1998 material to see tests and study questions from several years back. (Be aware that my style of test-writing has changed quite a bit since then.)

Chapter One -- Principles of Programming and Software Engineering
• Be able to discuss the phases of the software life-cycle and the relationship of documentation to these phases.

• Be able to define a "good" solution to a programming problem.

• Be able to discuss the elements of good software design such as modular design, abstraction and information hiding, object-oriented design, top-down design.

• Be able to discuss good programming style rules.

Chapter Six -- Stacks

• Be able to discuss the stack as an abstract data structure -- elements -- organization -- operations.

• Have a good understanding of how to implement a stack either using arrays or linking.

• Understand the performance tradeoffs among various implementations of a stack.

• Know how to write programs that use stacks.

Chapter Seven -- Queues

• Be able to discuss the queue as an abstract data structure -- elements -- organization -- operations.

• Have a good understanding of how to implement a queue either using arrays or linking.

• Understand the performance tradeoffs among various implementations of a queue.

• Know how to write programs that use queues.

Chapter Nine -- 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). (Here we use the notation b^c to denote "b raised to the power c.")

• 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.

• Be able to discuss the improvements to quicksort discussed in the text and in lectures.

Chapter Eight -- Class Relationships

• 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 Ten -- 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 Eleven -- Tables and Priority Queues

• Know what the "basic operations" are that "define the ADT table" (c.f. pp. 517-519). Understand what these operations do well enough to write specifications for them.

• Be aware of the advantages and disadvantages of various implementations of the ADT table. In particular if I name a table operation, you should be able to discuss how efficient that operation can be made in various table implementations.

• Know what the "basic operations" are that "define the ADT priority queue" (c.f. pp. 536-537). Understand what these operations do well enough to write specifications for them.

• Understand how to implement a priority queue using an ordered list, binary search tree, or heap. Understand the advantages and disadvantages of the various implementations.

• 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.

Chapter Twelve -- Advanced Implementations of Tables

• 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.

• 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 Thirteen -- 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.