Improve the writing in the cs101F2019_studyguide_exam02.

exam02/cs101F2019_studyguide_exam02.tex

@@ -108,7 +108,7 @@ \section*{Introduction}
     \program{ls}); building and running Java programs with Gradle; knowledge of
     the basic commands for using Docker and GitHub
 
-  \item Your class notes and the discussion slides available from the course web
+  \item The class notes and the discussion slides available from the course web
     site
 
   \item Source code and writing for all of the assigned laboratory and practical
@@ -240,15 +240,22 @@ \subsection*{Chapter Two}
 
   \item The goals, principles, and patterns of object-oriented design in the
     Java language
+
   \item An understanding of the principles known as abstraction, encapsulation, and modularity
+
   \item How to use inheritance hierarchies to create an ``is a'' relationship
     between Java classes
+
   \item The meaning and purpose of abstract classes and interfaces in the Java
     programming language
+
   \item How to create, catch, and handle exceptions thrown in a Java program
+
   \item How to performing casting to convert a variable from one data type to another
+
   \item The ways in which generics promote the implementation of reusable Java
     programs
+
   \item Knowledge of the Java syntax needed to declare data structures
     that are generically typed
 
@@ -262,22 +269,36 @@ \subsection*{Chapter Three}
   \setlength{\itemsep}{0.05in}
 
   \item How to use arrays to store primitive and reference variables
+
   \item The algorithms for sorting arrays into ascending and descending order
+
   \item How to use psuedo random number generators in Java programs
+
   \item The similarities and differences between one- and two-dimensional arrays
+
   \item The meaning and purpose of techniques for cloning data structures
+
   \item The similarities and differences between ``deep'' and ``shallow'' copies
     of arrays
+
   \item How to use the Java methods to construct ``deep'' and ``shallow'' copies
     of data structures
+
   \item An understanding of the types of nodes in a \program{SinglyLinkedList} and \program{DoublyLinkedList}
+
   \item The benefits and trade-offs associated with the \program{SinglyLinkedList} and \program{DoublyLinkedList}
+
   \item Knowledge of the worst-case time complexity for all methods of node-based structures
+
   \item Why the \program{removeLast} implementation is inefficient when
     implemented in a \program{SinglyLinkedList}
+
   \item The meaning of the term ``equivalence testing'' and how it connects to data structures
+
   \item The ``equivalence relationship'' that must be upheld by, for instance, a \program{DoublyLinkedList}
+
   \item The trade-offs associated with using either arrays or linked lists to implement data structures
+
   \item The benefits that come from using Java's generics to implement node-based list
     structures
 
@@ -292,25 +313,36 @@ \subsection*{Chapter Four}
 
   \item A strategy for timing the implementation of an algorithm in the Java
     programming language
+
   \item The challenges associated with experimentally studying an algorithm's
     performance
+
   \item A comprehensive understanding of why to use a doubling experiment to
     study efficiency
-  \item An understanding of all of the steps and source code needed to conduct a
+
+  \item An understanding of all the steps and source code needed to conduct a
     doubling experiment
-  \item The challenges associated with conduct an experimental evaluation of an
+
+  \item The challenges associated with conducting an experimental evaluation of an
     algorithm
+
   \item The meaning and purpose of the terms ``basic operation'' and ``psuedo code''
+
   \item An intuitive understanding of best-, worst-, and average-case analytical
     evaluations
+
   \item Knowledge of the seven functions used to characterize an algorithm's
     complexity class
+
   \item The relationship between an order-of-growth ratio and the worst-case
     time complexity
-  \item The meaning of the ``Big-Oh'' notation used during the
+
+  \item The meaning of the ``Big-Oh'' notation used as part of the
     analytical evaluation of algorithms
+
   \item Knowledge of the patterns in psuedo code that suggest certain
     worst-case time complexities
+
   \item How to intuitively prove the worst-case time complexity of an algorithm
     using psuedo code
 
@@ -403,8 +435,8 @@ \subsection*{Chapter Eight}
   \item The benefits that come from using Java's generics to implement
     a \program{Tree} data structure
 
-  \item The formal definition of a tree $T$ as a data structure with a set of
-    nodes related by edges
+  \item The intuitive definition of a tree $T$ as a data structure with a set
+    of nodes related by edges
 
   \item The meaning of tree-related terms such as ``subtree'', ``ancestor'',
     ``descendent'', and ``leaf''
@@ -430,8 +462,8 @@ \subsection*{Chapter Ten}
 
 \begin{itemize}
 
-  \item The meaning of the term ``associative array'' and how it is evidenced in
-    the \program{HashMap} structure
+  \item The meaning of the term ``associative array'' and how it is implemented
+    in the \program{HashMap}
 
   \item Knowledge of how other data structures create an ``associative array''
     with efficiency problems