# ICS 311 Fall 2017 Topics

This gives a conceptual overview of how the topics are grouped and overall sequencing. The exact coverage and sequencing for a given semester may vary.

## Part I: Introduction to Analysis

This section introduces algorithms as abstractions of programs, and motivates why we need to do analysis of algorithms rather than just run empirical tests of programs. It then introduces some mathematical and conceptual tools for doing analysis. Two useful sorting algorithms are used for illustration; we'll return to sorting later.

• #1 - Introduction to Course Format and to Algorithms: Chapter 1 CLRS
• #2 - Examples of Analysis with Insertion and Merge Sort: Chapter 2 CLRS
• #3 - Growth of Functions and Asymptotic Concepts: Chapter 3 CLRS

## Part II: Data Structures for Dictionaries & Sets

In this section we introduce problem solving and analysis methods (chapters 3-5), some of which have been covered in ICS 241, and also review review basic data structures and algorithms (chapters 10-12) that were introduced in ICS 211. The chapters from the text are interleaved and paired up in a manner that uses the basic dictionary and set data structures and algorithms to illustrate the problem solving and analysis methods. This is mostly review of the two prerequisite courses with some added depth.

• #4 - Stacks, Queues, Lists and Trees (Review): Chapter 10 CLRS
• #5 - Probabilistic Analysis and Randomized Algorithms & Skip list example: Chapter 5 CLRS & Goodrich & Tamassia section to be provided
• #6 - Hash Tables: Chapter 11 CLRS
• #7 - Divide & Conquer and Associated Analysis Methods: Chapter 4 CLRS Sections 4.1 & 4.3-4.5
• #8 - Binary Search Trees: - Chapter 12 CLRS Sections 12.1-12.3

## Part III: Sorting and Balanced Trees

We continue into more advanced applications of trees (chapters 6 and 13), also providing the basis for another efficient sorting algorithm. We compare additional sorting algorithms to those from Chapter 2. Sorting is one of the most fundamental and common applications of computers, so efficiency is very important. We consider the broader question of how fast any sort algorithm can be. This is an example of a powerful method of computer science: reasoning about sets of possible algorithms rather than specific algorithms.

• #9 - Heapsort and Priority Queues: Chapter 6 CLRS
• #10 - Quicksort, Theoretical Limits, and O(n) sorts: Chapters 7 & 8 CLRS
• #11 - Balanced Trees: - Sedgewick Chapter 15 (to be provided) & Chapter 13 CLRS

## Part IV: Problem Solving and Analysis Methods

This part introduces two further problem solving methods, dynamic programming and greedy algorithms, with example applications. We then cover another important analytic method, amortization , with examples in the analysis of the union-find representation of sets. (Topic #14 is a graph topic, next section, but will be introduced before #15 and #16, which use a graph example.)

• #12 - Dynamic Programming: Chapter 15 CLRS (see also Sedgewick Chapter 37)
• #13 - Greedy Algorithms & Huffman Codes: Chapter 16 CLRS Sections 16.1-16.3
• #15 - Amortization: Chapter 17 CLRS Sections 17.1-17.2
• #16 - Sets and Union-Find: Chapter 21 CLRS Sections 21.1, & 21.3 (merged into one day with #15)

## Part V: Graphs

Graphs are a very flexible data structure for which many applications exist. Equipped with various problem solving and analytic tools, we examine the most important algorithms on graphs -- including some of the most classic work in computer science -- and their applications.

• #14 - Graph Representations and Basic Algorithms: Chapter 22 CLRS (covered earlier)
• #17 - Minimum Spanning Trees: Chapter 23 CLRS
• #18 - Single-Source Shortest Paths: Chapter 24 CLRS Sections 24.1-24.3
• #19 - All Pairs Shortest Paths: Chapter 25 CLRS
• #20 - Maximum Flow Chapter 26 CLRS Sections 26.1-26.3

## Part VI: Selected Topics

There are a number of other important or common application areas that have their own specialized algorithms of interest: multithreading (parallel algorithms), matrix operations, linear programming, operations on polynomials, number-theory, string matching, and computational geometry. These are covered in the text, but we can't fit them all in. At the instructor's discretion, some of these topics will be covered. Linear Programming fills out an area not covered well above (numeric algorithms), and also has interesting connections to previous material (e.g., you can solve flow problems with a linear program). Multithreading is important with today's multi-core and GPU machines, and string matching is central to many applications.

• #21 - Linear Programming: Sedgewick (1983) Chapters 5 and 38 (read these first) & CLRS Sections 29.0-29.3 (first part)
• #22 - Multithreading: Chapter 27 CLRS (emphasis on Sections 27.1 and 27.3)
• #23- String Matching: Chapter 32 CLRS (emphasis on Sections 32.1 and 32.3)

## Part VII: Complexity Theory and NP-Completeness

Finally, abstracting further from algorithms to problems, we deal with the important question of whether an efficient algorithm is known (or even possible) for a given problem, and what to do if none are known. We encounter the most important open problem in theoretical computer science, which is also of practical interest because awareness of "intractable" problems and approximation algorithms could save you considerable trouble if you encounter one of these very common problems on the job! The seminal book on this topic by Garey & Johnson is the most cited reference in computer science.

• #24 - Complexity Theory & NP-Completeness: Chapter 34 CLRS
• #25 - Approximation Algorithms: Chapter 35 CLRS

Dan Suthers