COT 5410 Course Calendar
WeekDateCoverageAssignments Due Date
1 Details 8/25 Course Syllabus, Chapters 1, 2, 3 Assignment 1 9/15
2 Details 9/1 Chapters 4, 6, 7, 8.1 Assignment 1 9/15
3 Details 9/8 Sorts continued Assignment 1 9/15
4 Details 9/15 Sequential and Binary Search Assignment 2 10/6
5 Details 9/22 Positional and Associative Data Structures Assignment 2 10/6
6 Details 9/29 Set < Hash > Assignment 2 10/6
7 Details 10/6 Binary Tree and Binary Tree Iterators Assignment 3 11/10
8 10/13 Midterm Exam: Covers weeks 1-6
9 Details 10/20 Set < Binary Search Tree > Assignment 3 11/10
10 Details 10/27 Set < Red-Black Tree > Assignment 3 11/10
11 Details 11/3 Graphs, Digraphs, Breadth First Search Assignment 3 11/10
12 Details 11/10 Other Graph Algorithms Paper Topics  
13 Details 11/17 Student Presentations
14 11/24 Thanksgiving Eve - no class
15 Details 12/1 Student Presentations
16 12/8 Final Exam: Cummulative exam covers entire course
Note: Otherwise uncited references to chapters, sections, exercises, and problems refer to the course textbook Introduction to Algorithms, T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein, second edition, MIT press, 2001 (ISBN 0-262-03293-7).
Details: Week 1
Topics: Introduction
Growth of Functions
Analyzing Algorithms
Objectives: At the end of this class the student should be able to:
  1. Describe the course policies and grading criteria.
  2. Define algorithm in the strict sense and relate the definition to the meaning of the word in the text.
  3. Define Big O, Big Theta, Big Omega, little o, and little omega and state and prove the basic relationships among them.
  4. Describe the algorithm hypotheses and body for InsertionSort.
  5. Prove correctness of InsertionSort.
  6. Provide runtime analysis for InsertionSort.
Reading: Course Syllabus Textbook: Chapters 1, 2, 3
Suplemental: Notes 1: Introduction to Algorithms
Formulas
Exercises: 1.2-3, 2.1-3, 2.2-2, 2.3-3, 3.1-3, 3.1-4
Assignment: Assignment 1 Problem 1: Problem 3-1 on p. 57
Assignment 1 Problem 2: Problem 3-2 on p. 58
Details: Week 2
Topics: Recurrences
Objectives: At the end of this class the student should be able to:
  1. Apply the substitution method and tree method to obtain asymptotic solutions of recurrences.
  2. Solve the Fibonacci recurrence exactly (using the characteristic polynomial) and asymptotically
  3. State the Master Method for finding asymptotic solutions for recurrences.
  4. Apply the Master method to find asymptotic bounds on certain recurrences.
Reading: Textbook: Chapters 4, 6, 7, 8.1
Suplemental: Notes 2: Recurrences
Formulas
Exercises: 4.3-1, 4.3-3, 6.1-1, 6.1-3, 6.1-5, 6.2-5, 6.2-6, 6.4-3, 6.4-4,
Assignment: Assignment 1 Problem 3: Problem 4-5 on p. 86
Assignment 1 Problem 4: Problem 6-1 on p. 142
Assignment 1 Problem 5: Problem 7-4 on p. 162
Details: Week 3
Topics: SimpleSort, MergeSort, HeapSort QuickSort
Objectives: At the end of this class the student should be able to:
  1. Describe the algorithm hypotheses and body for SimpleSort, MergeSort, HeapSort, and QuickSort
  2. Give the best, average, and worst case runtimes for SimpleSort, MergeSort, HeapSort, and QuickSort, and outline the proofs.
  3. Prove correctness of SimpleSort, MergeSort, HeapSort, and QuickSort
  4. Derive and prove the best case asymptotic runtime for a comparison sort, and apply the results to InsertionSort, SelectionSort, MergeSort, HeapSort and QuickSort
  5. Describe the pros/cons of choosing one of these sorts over another in a given practical setting.
Reading: Textbook: Chapters
Suplemental: Notes 3: Sorting
Formulas
Exercises: 7.1-1, 7.1-3, 7.2-3, 7.2-4, 7.4-2
Assignment: Assignment 1 Problem 6: Prove correctness (including halting) of SimpleSort (use loop invariants)
Assignment 1 Problem 7: Provide worst and average case runtime analysis of SimpleSort
Assignment 1 Problem 8: Provide runspace analysis of SimpleSort
Details: Week 4
Topics: SequentialSearch, BinarySearch
Objectives: At the end of this class the student should be able to:
  1. Describe the algorithm hypotheses and body for SequentialSearch and BinarySearch
  2. Prove correctness of SequentialSearch and BinarySearch.
  3. Derive the worst and average case runtime of SequentialSearch and BinarySearch
Reading: Textbook: Chapters
Suplemental: Notes 4: Searching
Formulas
Exercises: Halting of BinarySearch
Correctness of BinarySearch
Runtime analysis of BinarySearch
Runspace analysis of BinarySearch
Assignment: Assignment 2 Problem 1: Prove correctness of SequentialSearch
Assignment 2 Problem 2: Worst and average case runtime analysis of SequentialSearch
Assignment 2 Problem 3: Prove correctness of BinarySearch
Assignment 2 Problem 4: Worst and average case runtime analysis of BinarySearch
Assignment 2 Problem 5: Explain why there is no short circuit bailout in BinarySearch
Details: Week 5
Topics: Positional and Associative Data Structures
Objectives: At the end of this class the student should be able to:
  1. Define each of the following ADTs in terms of public interface or operations:
    1. Vector
    2. List
    3. Deque
    4. Stack
    5. Queue
    6. Set
    7. MultiSet
    8. Table / Map / Associative Array
    9. MultiMap
  2. Classify these ADTs as positional or associative
  3. Give runtime requirements for the operations in the positional ADTs above
  4. Discuss tradeoffs for various runtime requirements for the operations in the associative ADTs above
Reading: Textbook: Chapters 10, 12
Suplemental: Notes 5: Sequential ADTs and Data Structures
Notes 6: Associative ADTs
Exercises: 10.2-1, 10.2-5, 10.3-1, 12.1-1, 12.3-3
Assignment: Assignment 2 Problem 6: Exercise 10.2-7 on p. 209
Assignment 2 Problem 7: Exercise 12.1-3 on p. 256
Details: Week 6
Topics: Hashing Implementatons of Set and Table (Unsorted)
Objectives: At the end of this class the student should be able to:
  1. Define and give examples of hash function
  2. Show the structure of hash table implemented with chaining
  3. Define uniform hashing
  4. State the expected access time for hash tables, and prove these assertions
Reading: Textbook: Chapter 11
Suplemental: Notes 7: Searching in Hash Structures
Exercises: 11.2-2, 11.2-3
Assignment: Assignment 3 Problem 1: Exercise 11.2-3 on p. 229
Assignment 3 Problem 2: Exercise 11.2-5 on p. 229
Details: Week 7
Topics: Binary Trees
Binary Tree Iterators
Objectives: At the end of this class the student should be able to:
  1. Discuss representation of trees and binary trees using dynamically created nodes
  2. Discuss binary tree iterators
  3. Explain why the increment operator ++ for a binary tree iterator has amortized constant runtime
Reading: Textbook: Chapter Appendix B.5
Suplemental: Notes 8: Binary Trees
Exercises:  
 
 
Assignment: Assignment 3 Problem 3: For the following binary tree, complete the table showing each step in a traversal and the number of edges covered by each step (begin, next, ... , next): 
                      iteration step  current location  no of edge moves
         Q            --------------  ----------------  ----------------
      /     \         1. initialize
     W       E        2. ++
      \     / \       3. ++
       R   T   Y      ...
                      7. ++           (null)
Details: Week 9
Topics: Binary Search Trees as ordered binary trees
Sets as Binary Search Trees
Objectives: At the end of this class the student should be able to:
  1. Define Binary Search Tree (BST) in terms of order on a Binary Tree
  2. Show that binary tree iterators encounter BST vertices in sorted order
  3. Describe the BST Search, Insert, and Delete algorithms
  4. Estimate the asymptotic runtime of BST Search
  5. Describe the BST implementation of Set
Reading: Textbook: Chapter 12
Suplemental: Notes 8: Set < Binary Search Tree >
Exercises:  
 
 
Assignment: Assignment 3 Problem 4: Describe an order in which vertices of a BST can be saved to ensure that reconstructing a BST from the saved data will result in the same tree. Argue correctness of your assertion.
Details: Week 10
Topics: Red-Black Trees Implementation of Set and Table (Sorted)
Objectives: At the end of this class the student should be able to:
  1. Define Red-Black Tree
  2. Illustrate specific instances of red-black trees
  3. Discuss the algorithms LeftRotate and RightRotate
  4. Discuss insertion and deletion in red-black trees
  5. State and prove the worst-case runtime for set operations, when the set is implemented as a red-black tree
Reading: Textbook: Chapter 13
Suplemental: Notes 9: Red-Black Trees
Exercises: 13.1-2, 13.1-6, 13.2-1, 13.3-2
Assignment: Assignment 3 Problem 5: Exercise 13.2-4 on p. 279
Assignment 3 Problem 6: Exercise 13.3-5 on p. 287
Details: Week 11
Topics: Graphs, Digraphs, Breadth First Search (BFS)
Objectives: At the end of this class the student should be able to:
  1. Define Graph, Directed Graph (Digraph), and Network
  2. Describe adjacency matrix representations of graphs, digraphs, and networks
  3. Describe adjacency list representations of graphs, digraphs, and networks
  4. Discuss how additional vertx and/or edge data can be assoicated with these representations
  5. Describe the BFS algorithm on a graph or digraph G with Queue control
  6. Explain why the runtime of BFS is O(V + E) (where V is the number of vertices of G and and E is the number of edges of G)
  7. Define the BFS Tree of a BFS search of G
  8. Explain the relationship between the BFS tree and shortest paths in G
Reading: Textbook: Chapters
Suplemental: Notes 10: Graphs and Digraphs
Exercises:  
 
 
Assignment: Assignment 3 Problem 7: Exercise 22.1-1 on p. 530
Assignment 3 Problem 8: Exercise 22.2-2 on p. 538
Details: Week 12
Topics: Depth First Search (DFS), Topological Sort
Objectives: At the end of this class the student should be able to:
  1. Describe the DFS algorithm with Stack control
  2. Explain why the runtime of DFS is O(V + E)
  3. Define the DFS Forrest of a DFS search
  4. Define the DFS [discovered,finished] interval for the vertices of G, and explain the Parenthesis Theorem
  5. Describe the Topological Sort problem for a Digraph
  6. Explain how DFS can produce a Topological Sort
Reading: Textbook: Chapters
Suplemental: Notes 10: Graph Algorithms
Exercises:  
Assignment: Assignment 3 Problem 9: Exercise 22.4-1 on p. 551
Assignment 3 Problem 10: Exercise 22.4-5 on p. 552
Details: Student Presentations
Topics:
  1. Ernest Murray: Runtime cost comparisons: Interpreted v Compiled Programs
  2. Sarah Jones: Splay Tree Implementation of Set
  3. Sandra Coppedge: Runtime and Runspace as Software Requirements
Details: Student Presentations
Topics:
  1. George GilmanAnalysis of Quantum Framework Internals
  2. Steve KantorThe A* Search Algorithm
  3. Dyana VauseSkip-List Implementation of Set
  4. Ryan CloseAnalysis of Genetic Algorithms Internals
  5. Sharon McInnisThe Importance of Algorithm Proofs and Runtime Analyses in Management
  6. Shane SlusserWeb Search Algorithms
  7. Jason Holliday: Primality Algorithms