Goals and objectives are under development for each course within the Department of Computer Science. Draft statements for each course may be found on separate pages, available through the following links.
The following material is being moved to separate course pages. When this transition is completed, the following material will be deleted.
CSC 151, Functional problem solving
CSC 161, Imperative problem solving and data structures
CSC 161 provides foundational coverage of topics related to imperative problem solving, Unix/Linux programming environments, and data structures. Topics covered will include:
 Lowlevel, imperative problem solving and elements of C
 Macros
 Compiling, linking
 Preprocessing
 Assignment
 Conditionals:
if
, switch
 File I/O
 Arrays
 Loops
 Pointers and memory management
 Header files
 Strings
 Commandline arguments
 Structs
 Unions
 General topics
 Assert
 Binary representation of data (twoscomplement, IEEE floatingpoint)
 Recursion
 Loop invariants
 Linux
 Elementary
make
files
 Permissions
 I/O redirection

grep
 Editing with
emacs
or vi
 Abstract data types and data structures
 Linked lists (and doublylinkedlists and circular lists)
 Stacks and queues
CSC 207, Algorithms and objectoriented design
CSC 207 introducts objectorient problem solving, the Java programming language, and associated algorithms. An approximate list of topics follows:
 Java
 Basics
 Interfaces and classes
 Exceptions
 Strings
 Arrays vs. vectors
 Comparators; sorting
 Generics
 Java type system
 Iterators
 Negotiating the Java class libraries
 OOP
 Abstract data types, data structures, and algorithms
 Dictionaries
 Hash tables
 Binary search trees
 Priority queues
 Heaps
 Formalize upperbound efficiency analysis; big O notation
 Contrast results for small and large data sets
 Prove negligible role of lowerorder terms
 Program development
 Integrated development environments
 Unit testing
 Integration testing
 Possible additional topics
 Introspection
 Swing
 Introduction of tightbound analysis (big Θ)
CSC 301,
Analysis of Algorithms
CSC 301 examines the design, implementation, and efficiency of algorithms, extending the study begun in CSC 151 and continued in CSC 161, CSC 207, and MAT 218. The course has four main foci:
 Alternative strategies in the design of algorithms,
 Relationships between algorithms and data structures:
 Some algorithms (e.g., numerical methods) solve problems with little need for extensive data structures.
 Some algorithms evolve to support abstract data types (e.g., dictionaries) and their underlying data structures (e.g., arrays and linked lists), and
 Some algorithms require careful record keeping, requiring the design and use of their own internal data structures (e.g., adjacency matrices for graphs).
 Careful analysis of the efficiency of these algorithms, regarding both runtime performance and resource use
 Techniques for establishing algorithm correctness.
More specifically, CSC 301 has these highlevel goals:
 to gain proficiency in the use of fundamental strategies for algorithm development
 to understand and apply fundamental algorithms to a range of problems
 to learn representative algorithms that are largely independent of data structures, algorithms that support abstract data types and data structures, and algorithms that utilize their own data structures for record keeping
 to learn techniques for analyzing algorithms, such as instruction counts, recurrence relations, probability theory
 to understand and apply methods for showing the correctness of algorithms to solve sample problems
The objectives of CSC 301 include these capabilities:
 Students should be able to identify and explain at least five distinct strategies for algorithm development and provide at least one example illustrating each strategy.
 Students should be able to explain, implement, and analyze fundamental algorithms from several application domains, such as trees, graphs, strings, and dictionaries.
 When several different algorithms are available for a task, students should be able to apply careful analysis to determine conditions when one algorithm may be better, worse, or about the same effectiveness as another.
 Since algorithms are normally designed to help solve problems, students should be able to provide formal arguments regarding why an algorithm correctly addresses specified requirements.
Since the subject of algorithms and algorithmic analysis is vast, each offering of CSC 301 must select illustrative strategies, techniques, structures, and analyses. CSC 301 is not meant to be encyclopedic, but rather to lay a foundation that will enable students to develop, implement, and analyze algorithms that may address future problems that might be encountered.
The following topic listing suggests some possible topics for CSC 301. Time constraints preclude any offering of the course from covering all of these topics, and the evolution of the discipline may suggest alternative topics.
 strategies for algorithm development: possible approaches may include:
 greedy algorithms
 divideandconquer algorithms
 dynamic programming
 approximation algorithms
 local search
 randomized algorithms
 simulated annealing
 genetic algorithms
 multithreaded algorithms
 Problems with algorithms that have little need for extensive data structures: possible problem domains for consideration may include:
 random number generation
 finding roots of functions
 log n algorithms (e.g., bisection method)
 selfcorrecting algorithms (e.g., Newton's method)
 finding greatest common divisors (e.g., Euclid's algorithm)
 primality testing
 generating permutations, combinations, and partitions
 geometric determinations
 intersection of line segments
 convex hulls
 closet pair of points
 Algorithms supporting data structures: Possible data structures may include:
 Sorting array data
 quicksort, merge sort and/or heap sort
 lineartime sorting methods
 Tree structures
 Tree balancing
 Decision trees
 Analysis using trees
 efficiency limits on sorting algorithms
 Optimal binary search trees
 Redblack trees
 Interval trees
 Huffman algorithm
 File compression
 Multiway search trees
 Graphs
 Undirected graphs
 Spanning trees
 Graph connectivity
 Directed graphs
 Adjacency graphs
 Hamiltonian circuits
 Topological sort
 Single source shortest path
 Algorithms requiring auxiliary data structures: representative topics may include:
 String Processing
 Maps/Dictionaries/Hashing
 Open hash tables
 Closed hash tables
 Collision resolution
 Analysis
 Heaps and priority queues