Kingdom of Saudi Arabia ‫المملكة العربية السعودية‬

Ministry of Education ‫وزارة التعليم‬

University of Jeddah
ّ
‫جامعة جدة‬
College of Computer Science and Engineering ‫كلية علوم وهندسة الحاسب‬
Department of Computer Science and Artificial ‫قسم علوم الحاسب والذكاء االصطناع‬
Intelligence

Assignment 1
CCCS 314 Design and Analysis of Algorithms
Fall 2025

Submission Date/Time: 11 Nov 2024 before 23:59

Student Name: _________________________________ Student ID: ______________

Instructor Name Section

Instructions:
The assignment must be submitted before the allocated Date/Time.
The assignment must by uploaded on LMS / sent by email to [email protected].
Plagiarism will be punished according to university rules.

CLO Course Learning Outcomes Code of CLOs aligned

Code with program
1.1 Acquire basic knowledge of different classes of CS K1
algorithms and be able to choose the right algorithm for a
given problem.
1.2 Evaluate computational complexity of recursive and non- K2
recursive algorithms.

2.1 Apply suitable algorithms meeting the set of requirements S1

to solve problems in the domain of computer science.
2.2 Develop practical experience with techniques and software S2
tools to implement different algorithms for problem solving.

Max Score Student Score

PLO S1 / CLO 2.1 Question 1 5
Total 5

1/7
Question 1: [PLO S1 / CLO 2.1] [5 marks]

Write a 1000 to 1500 word report on Topological Sorting and what kind of problems
can be solved using this method.

Topological sorting is an essential concept in computer science, used

primarily in algorithms involving directed acyclic graphs (DAGs). For
a Directed Acyclic Graph (DAG), topological sorting is a linear
ordering of vertices such that, for every directed edge u→vu \rightarrow
vu→v, vertex uuu appears before vvv in the ordering. This kind of
sorting is widely applicable in scenarios where there is a need to respect
dependencies between items or tasks.

In this report, we will explain the general concept of topological sorting,

its algorithms, its applications in real-world problems, and its
limitations. By understanding topological sorting, students and
practitioners can gain insight into how to handle dependencies
efficiently and order tasks with constraints.

1. What is Topological Sorting?

The topological sort algorithm takes a directed graph and
returns an ordered list of nodes where each node appears before all
nodes it points to. Topological sorting is only feasible for directed
acyclic graphs (DAGs) because cycles imply circular dependencies,
making it impossible to arrange nodes in a strict linear order. The
output of a topological sort is not unique; there can be multiple valid
orders, particularly if certain nodes have no dependencies among
each other.
For example, suppose we have tasks A, B, and C, where A depends
on B, and B depends on C. A topological sort would yield an
ordering like C → B → A. If two tasks have no dependencies between
them, either task can come before the other, which leads to multiple
valid topological orders.

2/7
 2. Algorithms for Topological Sorting
There are two main algorithms for computing a topological sort
in a DAG: Kahn's Algorithm and the Depth-First Search (DFS)
Approach. Each algorithm takes a different approach to organizing
the graph into a topologically sorted order.

2.1 Kahn’s Algorithm

Kahn's algorithm is an iterative method that uses the
concept of indegrees (the number of incoming edges for each
node) to determine the order of nodes in the graph.
Steps of Kahn’s Algorithm:
1. Calculate the indegree of each node in the graph.
2. Identify all nodes with an indegree of zero (i.e., nodes with no
dependencies) and add them to a queue.
3. While the queue is not empty, remove a node from the queue,
add it to the sorted order, and reduce the indegree of all
adjacent nodes by 1.
4. If any adjacent node’s indegree becomes zero, add it to the
queue.
5. Repeat this process until all nodes are processed.
Time Complexity: Kahn's algorithm runs in O(V+E), where V is
the number of vertices and E is the number of edges. This makes it
efficient for large, sparse graphs.

2.2 Depth-First Search (DFS) Approach

The DFS approach uses recursion and stack-based processing to achieve
topological sorting.
Steps of DFS for Topological Sorting:
1. Perform a DFS starting from any unvisited node.
2. During the DFS, mark nodes as visited. After visiting all adjacent
nodes, push each node onto a stack.
3. Once all nodes have been visited, the stack contains nodes in
topological order. Reversing this stack provides the sorted result.
The DFS approach is widely used in algorithms analysis
because it reinforces the concept of recursion and stack-based
processing.

3/7
 Time Complexity: Like Kahn's Algorithm, the DFS-based approach
also runs in O(V+E), making it similarly efficient.

3. Applications of Topological Sorting

Topological sorting has a range of applications in computer
science, especially in problems involving dependency management.
Below are some of the most common uses for topological sorting in
practice:
3.1 Task Scheduling and Project Management
In task scheduling, some tasks cannot begin until others are
completed. Topological sorting helps generate a valid
sequence for completing tasks based on their dependencies. By
representing each task as a node and each dependency as a
directed edge, we can apply topological sorting to derive a
feasible order of completion.

Example: In a software development project, certain features

depend on foundational modules. By applying topological
sorting, we can determine the correct order in which tasks
should be completed to ensure dependencies are respected.

3.2 Course Prerequisites in Academic Planning

Educational institutions often use prerequisites for course
sequences, where certain courses must be taken before others. By
applying topological sorting on a course dependency graph, we
can design a course plan that respects prerequisites. This helps
students understand a feasible order for course completion and
ensures that degree requirements are met in a logical order.

Example: A degree program with courses A, B, and C, where

A is a prerequisite for B, and B for C, would yield a topological
order of A → B → C.

4/7
 3.3 Dependency Resolution in Package Managers
In programming environments, package managers (e.g., npm for
JavaScript or apt for Linux) use topological sorting to manage
dependencies among packages. Before installing a package, its
dependencies must be installed first. A topological sort determines
the correct order for installation, preventing missing dependencies.

Example: If package A depends on B, and B depends on C, a

package manager will use topological sorting to ensure C is installed
first, followed by B, and then A.

3.4 Circuit Design and Verification

In digital circuit design, components often have dependencies
based on the logic and data flow. Topological sorting can determine
the order of operations, ensuring that inputs are processed before the
outputs they influence. This method is particularly useful in
evaluating combinational circuits, where sequential processing is
necessary for accurate simulation.

Example: In a digital circuit with gates G1, G2, and G3, where
G3 depends on G2, and G2 on G1, a topological sort yields an order
like G1 → G2 → G3, ensuring signals propagate in the right order.

3.5 Build Systems in Software Development

Build systems like Make or Gradle in software development use
topological sorting to order the compilation of files based on
dependencies. By ordering source files and modules in a way that
respects their dependencies, topological sorting helps prevent
compilation errors and facilitates efficient project builds.

5/7
 3.6 Data Serialization in Databases
In databases, data serialization involves saving and restoring data
structures with dependencies. Tables with foreign key constraints
need to be serialized in a specific order to maintain referential
integrity. Topological sorting provides a way to determine this order,
ensuring that referenced data is created before the data that depends
on it.

Example: In a database with tables for authors and books, where

books reference authors, topological sorting ensures authors are
inserted first to prevent integrity issues.

4. Limitations of Topological Sorting

Despite its utility, topological sorting has limitations:

1. Cycle Detection: Topological sorting cannot handle cyclic graphs.

If a cycle exists, a valid order is impossible. Therefore, detecting
cycles is crucial before applying topological sorting in applications
where cycles may arise.

2. Non-Uniqueness: Multiple valid topological sorts may exist in cases

with several nodes having no dependencies. This can introduce
variability in applications requiring deterministic ordering.
3.
4. DAG Requirement: Topological sorting is only applicable to
DAGs. Many real-world problems are not naturally represented as
DAGs, limiting its applicability.

5. Example Problem
Problem: Given n tasks with dependencies, determine if it is
possible to complete all tasks. If so, provide a completion order.
Solution:
1. Represent tasks as nodes and dependencies as directed edges in a
DAG.

6/7
 2. Use Kahn's algorithm or the DFS-based method to perform a
topological sort.
3. If the topological sort includes all nodes, a valid order exists;
otherwise, there is a cycle, and completing all tasks is impossible.
4.
6. Conclusion
Topological sorting is a key tool in algorithm design and analysis,
offering efficient solutions to ordering problems in directed acyclic
graphs. Its applications span project management, academic planning,
dependency management, circuit design, and more. Although it
requires a DAG and does not handle cycles, topological sorting’s linear
time complexity and versatility make it a powerful method in both
theoretical and practical computer science.

7/7