Dear CS 2500 Class --

Here are study questions for the final.  This is a subset of
the other collection.
					-- john sarraille

======================================================================
Chapter One Goals:  Programming Tools
======================================================================

* Describe the general activities in the software life cycle.

* Describe the goals for quality software.

* Explain the following terms: software requirements, software
  specifications, algorithm, information hiding, abstraction.

* Be able to explain the use of "Big-O" to describe the amount
  of "work" done by an algolrithm.

* Be able to write a top-down design for a given problem,
  either in English or in pseudo-code.

* Be able to explain why it is desirable to separate logical
  properties from implementation in computer programs.

* Be able to list features that make a program readable and
  modifiable.


======================================================================
Chapter Two Goals:  Verifying, Debugging, and Testing
======================================================================

* Be able to identify several sources of program errors.

* Be able to describe strategies to prevent various categories
  of software errors.

* Be able to specify the preconditions and postconditions of a
  program segment or procedure.

* Be able to state several testing goals and to indicate when
  each would be appropriate.

======================================================================
Chapter Three Goals:  Data Design
======================================================================

* Be able to explain what is meant by "abstract data type" and
  "data encapsulation."

* Be able to define an abstract data type as a collection of
  data elements and a set of operations on the data.

* Be able to describe a data structure from three perspectives:
  application, abstraction, and implementation.

* Be able to use pointers.

* Be able to differentiate between static and dynamic
  allocation.

======================================================================
Chapter Four Goals:  Stacks
======================================================================

* Be able to describe the structure of a stack and its
  operations at a logical level.

* Be able to implement the stack abstract data type in the form
  of a static array implementation.

* Be able to implement the stack abstract data type as a linked
  data structure.

* Be able to explain the difference between static and dynamic
  allocation of the space in which the stack elements are
  stored.

* Be able to compare stack implementations in terms of use of
  storage space and Big-O approximations of the stack
  operations. 

* Be able to describe advantages and disadvantages of using
  dynamically allocated space to contain the stack elements.

* Be able to determine when a stack is an appropriate data
  structure for a specific problem.

======================================================================
Chapter Five Goals:  FIFO Queues
======================================================================

* Be able to describe the structure of a FIFO queue and its
  operations at a logical level.

* Be able to implement the FIFO queue ADT using a static
  array-based implementation.

* Be able to implement the FIFO queue ADT as a linked data
  structure.

* Be able to compare queue implementations in terms of use of
  storage space and Big-O approximations of the FIFO queue
  operations. 

* Be able to choose between a statically and a dynamically
  allocated structure.
    
* Be able to discuss the advantages and disadvantages to using a
  linked data structure.

* Be able to determine when a FIFO queue is an appropriate data
  structure for a specific problem.

======================================================================
Chapter Six Goals:  Linear Lists
======================================================================

* Be able to describe a list at a logical level.

* Be able to define a set of operations for the abstract list
  data type.

* Be able to describe how an ordered list may be implemented as
  an array-based structure or a linked structure.

* Be able to contrast the array-based and linked
  implementations of a list in terms of the Big-O
  approximations of their operations.

======================================================================
Chapter Eight Goals:  Programming With Recursion
======================================================================

* Be able to do the following, given a recursive routine:
	determine whether the routine halts,
	determine the base case(s),
	determine the general case(s),
	determine what the routine does,
	determine whether the routine is correct and, if it is
	not, correct it.

* Be able to do the following, given a simple recursive problem:
	determine the base case(s),
	determine the general case(s),
	design and code the solution as a recursive procedure
	or function.

* Be able to verify a recursive routine, according to the
  Three-Question Method.

* Be able to decide whether a recursive solution is appropriate
  for a given problem.

======================================================================
Chapter Nine Goals:  Binary Search Trees
======================================================================

* Be able to define and use the following terms:
        binary tree
	binary search tree
	root
	parent
	child
	ancestor
	descendant
	level
	height
	subtree
	
* Be able to define a binary search tree at the logical level.

* Be able to show what a binary search tree would look like
  after a series of insertions and deletions.

* Be able to implement the following binary search tree
  algorithms in pseudo-code:
	creating an empty tree,
	inserting an element,
	deleting an element,
	retrieving an element,
	replacing an element,
	counting the number of nodes,
	traversing a tree in preorder, inorder, and postorder.
	
======================================================================
Chapter Eleven Goals:  Sorting and Searching Algorithms
======================================================================

* Be able to implement the following sorting algorithms:
	selection sort
	
* Be able to demonstrate the steps in the algorithms and to
  implement the following search algorithms:
	sequential search of an unordered list

======================================================================
======================================================================