In this module, you will learn how to measure the efficiency of algorithms at design time. More specifically, you will learn about asymptotic notation to represent the efficiency of algorithms in terms of the time and space utilized by your algorithms. You will also revisit C fundamentals with the help of a few basic programs.

In this module, you will learn about linked lists, stacks, and queues, along with their applications to various domains of computing. You will learn to apply them to construct efficient algorithms for various problems. You will also be able to implement these data structures in C.

In this module, you will learn about top-down recursive algorithms, with a specific discussion on insertion sort and merge sort algorithms. Specifically, you will understand the recursive and iterative versions of these sorting algorithms along with their derivations of time and space complexities. You will also implement these algorithms on large tuple data read from files and compare the running time of these algorithms. Additionally, you will learn to implement linear and binary search algorithms over arrays.

In this module, you will learn about the quick sort algorithm, implement it and analyze its time complexity. You will additionally study a summary of comparison-based sorting algorithms, along with their lower bound time complexity. You will also learn non-comparison-based sorting algorithms, such as bucket sort and radix sort, along with their complexity analysis and implementation.

In this module, you will learn about dictionary ADT s, hash tables, and binary trees. You will understand various hashing schemes, such as linear chaining and open addressing, and analyze their performance for large data. You will also gain insights into binary trees, tree traversals, and their implementations.

In this module, you will learn to use binary search trees and AVL trees as dictionaries. You will learn to implement them and store large tuple data. You would also be able to compare the search performance of both the trees averaged over large datasets. Additionally, you would be able to derive the best and worst-case complexities of search, insert, and delete in binary search trees (BST s) and AVL trees.

In this module, you will learn about priority queues abstract data type (ADT ) and various kinds of tries. You will also learn to implement heaps for priority queues and use them to find efficient tries for file compression. Additionally, you will learn about tries, compressed tries, and suffix trees, along with their applications to various domains of computer science.

In this module, you will learn the fundamentals of graphs, the data structures used to represent them, and the breadth-first graph traversal algorithm. You will learn to use the breadth-first graph traversal to solve a few computational problems related to graphs, such as checking for bipartite graphs and counting the connected components. You will also be able to implement breadth-first traversal efficiently using the appropriate data structure.

In this module, you will learn about depth-first traversal in graphs and its applications to graph-related problems. You will learn to analyze its complexity and implement it efficiently. You will understand the minimum spanning trees (MST) problem in weighted graphs and study Kruskal’s algorithm that computes MST from a weighted graph. You will additionally learn to optimize the time complexity of Kruskal’s algorithm using the union-find data structure and implement it.

In this module, you will learn about Prim’s algorithm for computing the minimum spanning tree in a weighted graph. Additionally, you will also learn about Dijkstra’s algorithm to compute “single-source shortest paths.” You will also learn about the Bellman-Ford algorithm to compute “single-source shortest paths” in graphs with negative edge weights. You will also be able to implement these algorithms and analyze their time complexities.