Learn Data Structures using C Programming Language

Course Curriculum

Chapter 1: Course Details

Lecture 1: Prerequisites, Topics covered, and Reference book

Lecture 2: About quizzes and exercises

Chapter 2: Introduction to Data Structures

Lecture 1: Why study Data Structures and What is a Data Structure

Lecture 2: The Big-O notation for representation of performance measure of algorithms

Chapter 3: Arrays : An Introduction

Lecture 1: The definition of an array

Lecture 2: Array limits

Lecture 3: Element addressing in an array

Chapter 4: An application of arrays: Fast Transpose of a Sparse Matrix

Lecture 1: Introduction to Sparse Matrix Transpose

Lecture 2: Sparse matrix representation in a program

Lecture 3: First attempt at sparse matrix transpose: A crude solution

Lecture 4: Second attempt at sparse matrix transpose: A simple solution

Lecture 5: Third and final attempt: Fast Transpose of a Sparse Matrix

Chapter 5: Stacks and Queues: Introduction

Lecture 1: An Introduction to Stacks and Queues

Chapter 6: Stack functionalities

Lecture 1: Stack functionalities and "push" function

Lecture 2: "pop" function in Stacks

Chapter 7: An application of stacks: A Mazing Problem

Lecture 1: Stacks in Procedure Calls and Recursion

Lecture 2: Introduction to A Mazing Problem

Lecture 3: Recursive solution to A Mazing problem: A partial solution

Lecture 4: Recursive solution to A Mazing problem: A full solution

Lecture 5: Non-recursive solution to A Mazing Problem

Chapter 8: Queue functionalities

Lecture 1: Queue definitions and Linear Queue

Lecture 2: Circular Queue

Chapter 9: Linked Lists

Lecture 1: Why do we need linked lists?

Lecture 2: What is a linked list?

Lecture 3: Creation of a linked list

Lecture 4: Insertion of a new node in between two nodes in a singly linked list

Lecture 5: Insertion of a new node at the corners in a singly linked list

Lecture 6: Deletion of a node in a singly linked list

Lecture 7: Inplace reversal of a singly linked list

Lecture 8: Insertion and deletion of a node in a doubly linked list

Chapter 10: Trees : An Introduction

Lecture 1: Terms associated with Tree data structure

Chapter 11: An application of Trees : "Set" representation

Lecture 1: Representation of trees using array

Lecture 2: Union of two disjoint sets : First version: A simple union

Lecture 3: Find the root element of a tree: First version: A simple find

Lecture 4: Union of two disjoint sets : Second version: Weighted union

Lecture 5: Find the root element of a tree: Second version: Reduction in tree height

Chapter 12: Binary Trees

Lecture 1: Definition of a binary tree and Types of binary trees

Lecture 2: Some interesting properties of binary trees

Lecture 3: Representation of binary trees using arrays

Lecture 4: Representation of binary trees using linked lists

Lecture 5: Binary Tree Traversal

Lecture 6: Inorder, preorder, and postorder traversals : An Introduction

Lecture 7: Inorder, preorder, and postorder traversals : An Implementation

Chapter 13: Graphs : An Introduction

Lecture 1: Basic Graph Terminologies

Lecture 2: Complete graph and Subgraph

Lecture 3: Connected component of a graph

Lecture 4: Degree of a vertex

Chapter 14: Graph Representation

Lecture 1: Graph representation using Adjacency Matrix

Lecture 2: Graph representation using Adjacency List

Lecture 3: Representation of a directed graph

Lecture 4: How to find out the degree of a vertex in a graph

Lecture 5: Inverse adjacency list for a directed graph

Chapter 15: Graph search: Depth First Search (DFS) and Breadth First Search (BFS)

Lecture 1: Depth First Search (DFS)

Lecture 2: Breadth First Search (BFS)

Lecture 3: Time estimates of DFS and BFS

Chapter 16: Graph application : Finding Connected Components of a graph

Lecture 1: How to find out the connected components of a graph using DFS/BFS

Chapter 17: Graph application : Minimum Spanning Tree algorithm

Lecture 1: Finding spanning trees using BFS or DFS

Lecture 2: What is a minimum spanning tree?

Lecture 3: The minimum spanning tree algorithm : Theory

Chapter 18: Implementation of the Minimum Spanning Tree Algorithm

Lecture 1: Extracting a list of unique edges from adjacency list

Lecture 2: Finding the edge with least cost from the list of unique edges

Lecture 3: Use of set union and find-root operations for detecting cycles in the tree

Lecture 4: Constructing the minimum spanning tree: Putting it all together

Chapter 19: Graph application: Dijkstra's Shortest Path Algorithm

Lecture 1: An introduction to the shortest path algorithm

Lecture 2: Data structures used in the shortest path algorithm

Lecture 3: Implementation of the shortest path algorithm as a program

Chapter 20: Internal Sorting Techniques : Introduction

Lecture 1: Introduction to Sorting

Lecture 2: Summary of some internal sorting techniques

Lecture 3: The nature of input data in internal sorting

Chapter 21: Internal Sorting: Insertion Sort

Lecture 1: Insertion Sort Algorithm

Lecture 2: Insertion sort : Time and space analysis

Chapter 22: Internal sorting : Quicksort

Lecture 1: Quicksort Algorithm (Recursive)

Lecture 2: Quicksort : Time analysis : Average case

Lecture 3: Quicksort : Time analysis : Worst case

Lecture 4: Quicksort : Space consumption

Lecture 5: Quicksort : Improvements (including non-recursive version)

Chapter 23: Internal sorting : Mergesort

Lecture 1: Mergesort : "merge" functionality and time & space analysis of "merge"