CS361 Outline
Spring 2024, Ashok Kumar Veerasamy
1 Preamble
Welcome to CS361
-
The course is divided into three parts. Each part contains multiple modules, including some assignments, and an exam.
-
Each module consists of a series of activities. These include reading, taking self-assessment quizzes & labs, and doing assignments.
-
Not every assigned activity requires you to submit something for grading. Nonetheless, you are expected to complete all of them.
-
If an activity is not marked with its own due date, then it is considered to be due at the end of the date range given for that module.
-
KEYS TO SUCCESS IN THIS COURSE:
-
READ THE SYLLABUS
The syllabus lays out the basic course policies. It tells you what you need to do to earn a passing grade. It tells you when you need to have done that by. It tells you how to get in touch with me if you run into problems.
-
HAVE A SCHEDULE
You have some freedom to schedule your own time in this course, but you DO need to set up a schedule. Don’t forget that this course exists and that you are registered for it. Don’t think you can repeatedly set it aside for weeks at a time and make up the time later.
-
IF YOU DON’T UNDERSTAND SOMETHING, ASK QUESTIONS
In a web course, my role as Instructor changes from “lecturer” to “tutor”. You can ask questions in the course Forums. You can send me email. You can also contact me during office hours. You’ll find more information on these options in the syllabus and other documents on the Course Policies page.
Some people are too shy to ask questions. Some are too proud to ask questions. My advice to both groups is to get over it! Part of being educated is knowing how to exploit your available information resources. In this course, I am one of those resources.
1 Part I 01/07/2024 - 02/17/2024
1.1 Overview and ADTs Review 01/07/2024 - 01/13/2024
Overview
Coming into this course, you should already be familiar with Abstract Data Types and with the way that C++ classes are used to implement them.
To be certain that everyone is on the same page, however, this module examines some critical information about data and functions in C++.
Most of this material should be review for you, though it may be presented from a different perspective than you are used to. If you find yourself completely lost in these readings and/or unable to complete the first assignment, you may need to plan on doing some very rapid but intense review of the prerequisite material (the Resources page has useful links) or even reconsider whether you are prepared to take this course.
- Orientation 01/11/2024, 5:00PM EST
- [Q&A Discussion Forum]
- Choosing Your Programming Environment
- Lab 1: Setting Up Your Programming Environment 01/13/2024
- How data is Stored in C++
- Functions in C++
- Comparing Data
- Copying Data and the "Rule of the Big 3"
- See website for assignment
1.2 Templates and Iterators 01/14/2024 - 01/20/2024
Overview
-
Templates are a mechanism for writing algorithmic patterns that can be applied to a wide variety of different data types.
-
Iterators are a data abstraction for the notion of a position within a container of data. Iterators allow us to express many simple algorithms in a simple form, regardless of whether the underlying container is an array, a linked list, a tree, or some other data structure.
Templates and iterators are often used together to provide patterns for code that can be applied to a wide range of underlying data structures.
- Algorithms as Patterns for Code
- Function Templates
- Class Templates
- The Standard Library: Overview
- Iterators: an ADT for Positions
-
Lab 2: Working with Iterators & Templates Due: 01/20/2024
1.3 Algorithm Analysis 01/21/2024 - 01/27/2024
Overview
An important theme throughout this semester will be viewing the process of developing software as an engineering process. Now, engineers in traditional engineering disciplines, civil engineers, electrical engineers, and the like, face trade offs in developing a new product, trade offs in cost, performance, and quality.
Software developers face the same kinds of choices. Early on, you may have several alternative designs and need to make a decision about which of those designs to actually pursue. It’s no good waiting until the program has already been implemented, written down in code. By then you’ve already committed to one design and invested significant resources into it.
In this module, we’ll look at mathematical techniques for analyzing algorithms to determine what their speed will be, or, more precisely, how badly their speed will degrade as we apply them to larger and larger amounts of data. The key to doing this will be to analyze the code for its worst case complexity.
- Analysis of Algorithms: Motivation
- Weiss, Ch 2
- Analysis of Algorithms: Worst Case Complexity
- Big-O Algebra (To find the self assessments, click on the “Quizzes” link in the left navigation bar on Canvas and scroll down to “Practice Quizzes”.)
- Complexity: step-by-step, short program fragments (in Canvas)
- Complexity: functions (in Canvas)
1.4 Sequences 01/28/2024 - 02/03/2024
Overview
A substantial amount of the data that we work with is arranged into a simple linear ordering, one thing after another. Of course, you are already quite familiar with one way of doing this, by putting the data into arrays.
In this module we explore the two most common variations on ADTs for maintaining data in a sequence: vectors and lists.
Vectors provide a mechanism for array-like sequences that can expand to accommodate the amount of data to be stored.
Lists allow for efficient insertion and removal of data from any location in the sequence, at the cost of limiting access to moving sequentially from one end of the list to the other.
- Weiss, Ch 3
- Vectors
- Lab 3: Working with Vectors Due: 02/01/2024
- Implementing the Vector Class
- Linked List Applications
- Standard Lists
- Linear Sequences
-
See website for assignment
1.5 Generic Programming 02/04/2024 - 02/10/2024
The combination of templates and iterators, combined with a wider range of container types, brings us to generic programming, an important and pervasive style of coding in C++.
- Review the exam procedures and set up your proctoring for the Part I exam. 02/04/2024
- Generic Programming
- Lab 4: Generic Programming Due: 02/10/2024
1.6 Stacks and Queues 02/11/2024 - 02/17/2024
Overview
Sometimes one can achieve more readable, expressive algorithms by using ADTS that limit one’s choices.
Stacks and queues do not do anything that a vector or list cannot, but they limit us to access and modify their contents only at the ends of the sequence, never in the interior. There are a number of useful algorithms that work perfectly within these limitations.
- Recursion
- Lab 5: Recursion Due: 02/14/2024
- Stacks
- Queues
-
See website for assignment
1.7 End of Part I
- Exam Procedures
- Exam 1 (on Canvas) 02/18/2024 - 02/19/2024
2 Part II 02/18/2024 - 03/31/2024
2.1 Average Case Complexity 02/18/2024 - 02/24/2024
Overview
In Part I, we analyzed the speed of algorithms exclusively from the point of view of the worst case. One might argue that this is unnecessarily pessimistic on our part. There are some algorithms for the worst case input is rare enough that we might not be worried about it, particularly if we believe that typical inputs can be handled much more quickly.
We therefore next turn to the idea of average case complexity a measure of how the average behavior of a program degrades as the input sets get larger and larger.
-
Case Study: Schemes to Improve the Average Case of Sequential Search
-
See website for assignment
2.2 Sorting 02/25/2024 - 03/02/2024
Overview
Sorting algorithms arrange data stored in a sequence into a new desired order.
Because the data structures involved are elementary (arrays, vectors, and, occasionally, linked lists) and because the need for sorted data arises in so many practical applications, you probably learned learned one or more sorting algorithms in your earliest programming classes.
But sorting is actually a fairly subtle problem, and the sorting algorithms taught to beginning programmers are chosen for simplicity, not performance. They are often slow and rather clumsy.
In this section we’ll look at more sophisticated sorting algorithms. We’ll also consider the fundamental limits on just how fast a sorting algorithm can get, and we’ll see that some practical algorithms actually approach that upper speed limit.
- Weiss, Ch 7
- Sorting --- Insertion Sort
- Sorting Speed Limits
- Sorting --- Merge Sort
- Sorting --- Quick Sort
- Lab 7: Sorting (in Canvas) Due: 03/02/2024
2.3 Trees 03/10/2024 - 03/16/2024
Overview
Most of the data structures we have looked at so far have been devoted to keeping a collection of elements in some linear order.
Trees are the most common non-linear data structure in computer science. Trees are useful in representing things that naturally occur in hierarchies (e.g., many company organization charts are trees) and for things that are related in a “is-composed-of” or "contains manner (e.g., this country is composed of states, each state is composed of counties, each county contains cities, each city contains streets, etc.)
Trees also turn out to be exceedingly useful in searching. Properly implemented, a tree can be both searched and inserted into in O(log N) time. Compare this to the data structures we’ve seen so far, which may allow us to search in O(log N) time but insert in O(N), or insert in O(1) but search in O(N).
General Trees
- Weiss, Ch 4
- Trees
-
See website for assignment
Search Trees
2.4 Sets and Maps 03/17/2024 - 03/23/2024
Overview
We have seen that trees are an efficient data structure for both searching and updating collections of data.
These can serve as the underlying data structure to implement associative containers like sets (collections of items with no duplicates) and maps (lookup “tables” that can search for data associated with keys).
-
Review the exam procedures and set up your proctoring for the Part 2 exam. 03/17/2024
- Maps and MultiMaps
-
Lab 8: Sets and Maps Due: 03/23/2024
2.5 Hashing 03/24/2024 - 03/30/2024
Overview
Hashing is an alternative to trees for providing fast associative containers (sets and maps).
Hashing stored data in arrays (primarily), but does not store them in any predictable order, or even contiguously. Instead, hashing uses a special “hash function” to compute a desired location for any key we want to insert. If you don’t actually know the internal details of the hash function, its choices of locations would seem arbitrary, almost random.
Nonetheless, it works, and in many cases works well. Hash tables can often store and search for data in O(1) average time.
- Hashing
- Weiss, Ch 5
- Resolving Collisions
- Rehashing (Variable Hashing)
- Hash-Based Sets and Maps
- Lab 9: Unordered Sets Due: 03/27/2024
-
See website for assignment
2.6 End of Part II
- Exam 2 03/31/2024 - 04/01/2024
3 Part III 03/31/2024 - 04/22/2024
3.1 Algorithm Design Techniques 03/31/2024 - 04/06/2024
Overview
By this point in the semester, you’ve learned a lot of algorithms. Many practical problems can be solved by direct application of these. But what do you do when faced with an unfamiliar problem, one for which none of the “canned” algorithms in your personal toolbox are suitable?
When you have to design your own algorithms, you should consider some of the common patterns or styles that are available to you. This lesson looks at these styles, many of which we have seen before, and a few new ones as well.
- Weiss, Ch 10
- Converting Recursion to Iteration
- A Gallery of Algorithmic Styles
-
See website for assignment
3.2 Heaps and Priority Queues 04/07/2024 - 04/13/2024
Overview
A priority queue is an ADT that allows us to repeatedly find and remove the largest (or smallest) item from a colleciton of data. They take their name from the idea that they implement a “queue” of items awaiting processing, but one in which some items have higher priority than others and so get to jump to the head of the line if nothing ahead has even higher priority.
Priority queues are generally implemented using heaps, a tree with very special ordering properties.
- Weiss, Ch 6
- Priority Queues
- Heaps
- Heapsort
- Review the exam procedures and set up your proctoring for the Final exam. 04/12/2024
3.3 Graphs 04/14/2024 - 04/22/2024
Overview
A graph is a collection of vertices (nodes) connected by edges in arbitrary fashion. Graphs are used to represent data relationships that are far more complicated than could be represented using trees or lists.
- Weiss, Ch 9
- Graphs --- the Basics
- Graphs --- Sample Algorithms
- Sharing Pointers and Garbage Collection
-
See website for assignment
3.4 End of Part III
- Final exam (cumulative) 04/29/2024 - 04/30/2024