3
1
0
3
Pre
requizitPrere
quisite
COCS 325
Registered
credits
Algorithms and Complexity
Training
Code/No
Lab
Course name
Lecture
Credits
COCS
304
Course Objectives:
 The ability to decide on the suitability of a specific technique for a given
problem
 The ability to analyze the complexity of a given algorithm.
 The ability to design efficient algorithms for new situations, using as building
blocks the techniques learned.
 The ability of use fundamentals of algorithms and algorithmic techniques.
Course Description:
This course teaches the standard algorithms of computing and their respective
complexity. The course teaches also complexity analysis of algorithms; design
and analysis of computer algorithms such as: divide and conquer, greedy method,
dynamic method, trees, and graphs.
Course Outlines:

Algorithmic Strategies
o Brute-force algorithms
o Greedy algorithms
o Divide-and-conquer
o Backtracking
o Branch-and-bound
o Heuristics
o Pattern matching and string/text algorithms
o Numerical approximation algorithms

Fundamental Algorithm
o Simple numerical algorithms
o Sequential and binary search algorithms
o Quadratic sorting algorithms (selection, insertion)
o O(N log N) sorting algorithms (Quicksort, heapsort, mergesort)
o Hash tables, including collision-avoidance strategies
o Binary search trees
o Representations of graphs (adjacency list, adjacency matrix)
o Depth- and breadth-first traversals
o Shortest-path algorithms (Dijkstra’s and Floyd’s algorithms)
o Transitive closure (Floyd’s algorithm)
o Minimum spanning tree (Prim’s and Kruskal’s algorithms)
o Topological sort

Distributed Algorithm
o Termination detection
o Fault tolerance
o Stabilization

Basic Computability
o Finite-state machines
o Context-free grammars
o Tractable and intractable problems
o Uncomputable functions
o The halting problem
o Implications of uncomputability
Course outcomes:
Upon finishing this course, the student should:
 Determine the time and space complexity of simple algorithms.
 Deduce recurrence relations that describe the time complexity of recursively
defined algorithms.
 Solve elementary recurrence relations.
 Describe the shortcoming of brute-force algorithms.
 Implement a greedy algorithm to solve an appropriate problem.
 Implement a divide-and-conquer algorithm to solve an appropriate problem.
 Use backtracking to solve a problem such as navigating a maze.
 Describe various heuristic problem-solving methods.
 Use pattern matching to analyze substrings.
 Use numerical approximation to solve mathematical problems, such as finding
the roots of a polynomial.
 Implement the most common quadratic and O(nlogn) sorting algorithms.
 Design and implement an appropriate hashing function for an application.
 Design and implement a collision-resolution algorithm for a hash table.
 Discuss the computational efficiency of the principal algorithms for sorting,
searching, and hashing.
 Discuss factors other than computational efficiency that influence the choice
of algorithms, such as programming time, maintainability, and the use of
application-specific patterns in the input data.
 Solve problems using the fundamental graph algorithms, including depth-first
and breadth-first search, single-source and all-pairs shortest paths, transitive
closure, topological sort, and at least one minimum spanning tree algorithm.
 Demonstrate the following capabilities: to evaluate algorithms, to select from
a range of possible options, to provide justification for that selection, and to
implement the algorithm in programming context.
 Design a deterministic finite-state machine to accept a specified language.
 Explain how some problems have no algorithmic solution.
Assessment Strategy:
Students will be assessed in this course based on a set of exams, quizzes and
practical parts of it.
Text Book:
 Cormen. T. et al., Introduction to Algorithms, 3rd Edition, MIT press, USA,
2009.
Other References:



M.T.Goodrich and R.Tamassia, Data Structures and Algorithms in Java, 5th
edition, John Wiley and Sons, Inc., 2010
M. H. Alsuwaiyel, Algorithms Design Techniques and Analysis. World
Scientific, 1999.
Sara Baase, Computer Algorithms: Introduction to design & Analysis, 4th
Edition, Addison Wesley Longman, 2001.
Time table for distributing theoretical course contents
Week
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Theoretical course contents
Introduction
Growth of Functions
Sorting algorithms (selection, insertion, bubble)
Sorting algorithms (selection, insertion, bubble)
Divide and conquer (Heap, Quicksort, mergesort)
Divide and conquer (Heap, Quicksort, mergesort)
Hash Table
Binary search Treee, Traversal and AVL
Binary search Treee, Traversal and AVL
Dynamic Programming
Gready Algorithm
Graph: intro, DFS and BFS
Graph: minimum spanning Trees
Graph: shortest path
Final exam.
Grading:
Project
Labs Exercises
Exam 1
Exam 2
Final Exam
TOTAL
10
20
15
15
40
100
Remarks
Exam 1
Exam 2