COP 3530 Common Topics, Objectives, and Grading Policy

Course Learning Objectives  

  • CLO1. Be familiar with basic techniques of algorithm analysis 
  • CLO2. Master writing recursive methods 
  • CLO3. Master the implementation of linked data structures such as linked lists and binary trees 
  • CLO4. Be familiar with advanced data structures such as balanced search trees, hash tables, priority queues and the disjoint set union/find data structure 
  • CLO5. Be familiar with several sub-quadratic sorting algorithms including quicksort, merge sort and heapsort 
  • CLO6. Be familiar with some graph algorithms such as shortest path and minimum spanning tree 
  • CLO7. Master the standard data structure library of a major programming language 
    • Java: java.util (e.g., ArrayList, LinkedList, HashMap)
    • Python: collections (e.g., deque, defaultdict, Counter)
    • C++: STL (e.g., std::vector, std::list, std::unordered_map)

  

Modules  

 Module 1 | Big-O Notation, Algorithm Analysis, and Recursion 

This module introduces the concept of algorithm and data structures as well as reviewing the concept of recursion. Also, it addresses how to analyze algorithms and their time complexities using asymptotic notations (Big-O notation). 

By the end of this module, students will be able to: 

  • Understand the concept of algorithms and abstract data types (CLO1) 
  • Explain how asymptotic notation can quantify the performance of algorithms (CLO1) 
  • Explain how recursive methods/functions are executed in a computer program (CLO2) 
  • Analyze the complexity of code snippets containing simple conditional, iterative and recursive statements (CLO1) 

Module 2 | Lists, Stacks, and Queues 

This module addresses how to construct, manipulate, and iterate through linked lists. It also studies the definition and implementation of list Abstract Data Type (ADT), stack ADT and queue ADT. Moreover, it addresses how they are used in a major programming. 

By the end of this module, students will be able to: 

  • Understand list ADT, stack ADT and queue ADT (CLO3) 
  • Explain how to construct, manipulate, and iterate through a linked list that stores a list of items (CLO3) 
  • Explain how stack ADT can be implemented using arrays/linked lists (CLO3) 
  • Explain how queue ADT can be implemented using arrays/linked lists (CLO3) 
  • Utilize lists, stacks and queues to store data in a major programming language (CLO7) 

 Module 3 | Trees 

This module introduces binary trees, tree traversals, and Binary Search Tree (BST) as an implementation of set ADT. It also explains how trees can be implemented and used in a major programming language. As an optional add-on, it introduces an example of balanced BST like AVL or red/black tree. 

By the end of this module, students will be able to: 

  • Define trees and their properties like height. (CLO3) 
  • Explain different ways to traverse nodes of a binary tree. (CLO2, 3) 
  • Define binary search trees and their properties. (CLO3) 
  • Explain how different operations of a set (add, remove, and search) are implemented in a binary search tree. (CLO3) 
  • Implement and utilize binary trees in a major programming language. (CLO3, 7) 

Module 4 | Hash Tables 

This module explains hash tables (including hash functions, collision resolution methods like separate chaining), as well as how they implement both set and map ADTs. In addition, it addresses how they are implemented and used in a major programming language. 

By the end of this module, students will be able to: 

  • Understand the general concept of hashing like hash functions and collision resolution mechanisms (CLO4) 
  • Explain how hash tables implement both set and map ADTs. (CLO4) 
  • Implement and utilize hash tables in a major programming language. (CLO4, 7) 

Module 5 | Priority Queues and Sorting Algorithms 

This module explains priority queue ADT and binary heaps as its popular implementation. It also studies different sorting algorithms like heap sort, merge sort, quick sort and bubble sort (and optionally, radix, insertion and shell sorts). 

By the end of this module, students will be able to: 

  • Define binary heap as an implementation of priority queue ADT (CLO4) 
  • Understand the task of sorting elements of a list (CLO5) 
  • Explain how bubble sort works and understand its time complexity (CLO1, 5) 
  • Explain how quick sort works and understand its time complexity (CLO1, 2, 5) 
  • Explain how merge sort works and understand its time complexity (CLO1, 2, 5) 
  • Explain how heap sort works and understand its time complexity (CLO1, 4, 5) 
  • Utilize priority queues and sorting algorithms in a major programming language (CLO4, 5, and 7) 

Module 6 | Disjoint Sets (Union-Find ADTs) 

This module introduces disjoint sets and union-find data structures.  

By the end of this module, students will be able to: 

  • Define disjoint-set data structures and both union and find operations (CLO4) 
  • Analyze the time-complexity of union and find operations on a disjoint-set data structure (CLO1, 4) 
  • Implement and utilize disjoint sets in a major programming language (CLO4, 7) 

Module 7 | Graphs and Graph Algorithms 

This module introduces graphs and their basic definitions and terminology. It also introduces basic graph algorithms like breadth-first search, topological sort, and depth-first search. It optionally covers more advanced graph algorithms like Dijkstra’s, Bellman-Ford’s, Kruskal’s and Prim’s algorithms. 

By the end of this module, students will be able to: 

  • Understand the basic definitions and terminology of graphs. (CLO6) 
  • Explain how to traverse graph nodes using breadth-first search traversal algorithm. (CLO6) 
  • Explain how to traverse graph nodes using depth-first search traversal algorithm. (CLO6) 
  • Explain the task of topological sorting and an algorithm (like Kahn’s) to perform it. (CLO6) 
  • Implement graphs and graph algorithms in a major programming language. (CLO6, 7) 

 

Cumulative Final Exam (Final Week)  

Grading Policy  

Grading Distribution  

Items   # of items   Weight of each item   Total weight  
Final Exam   1   25%   25%  
Discussions  4 12.5% 50%  
Quiz 6 (3 bonus pre-module quiz + 3 graded post module quiz) 12.5% 25%
Total     11    100%  

  

Letter-Grade Cutoff Points  

  

A table that contains the grading scheme data. Each row contains a name, a maximum percentage, and a minimum percentage.
Letter Grade Range
A 100%to95%
A- < 95%to90%
B+ < 90%to87%
B < 87%to83%
B- < 83%to80%
C+ < 80%to77%
C < 77%to70%
D < 70%to60%
F < 60%to0%