C Language + Algorithms + Data Structures = Power

Course Curriculum

Chapter 1: Course 101

Lecture 1: Introduction

Lecture 2: installing the development environment + Hello world Program

Lecture 3: Variables – Integers

Lecture 4: Variables – Non Integers

Lecture 5: Constants and Macros

Lecture 6: Operators

Lecture 7: Conditional Programming – IF statement

Lecture 8: Loops

Lecture 9: Arrays

Lecture 10: Functions – Theory

Lecture 11: Funcitons – Examples

Lecture 12: Struct

Lecture 13: Standard Input

Lecture 14: Pointers

Lecture 15: Application 1

Lecture 16: Variable scopes

Lecture 17: multidimensional Arrays

Lecture 18: Debbugging with The IDE

Lecture 19: Break – Continue

Lecture 20: enumerators – User Defined Values

Lecture 21: Pointers as function arguments

Lecture 22: Strings – Definition & Operations

Lecture 23: Strings – Functions

Lecture 24: Compiling manually

Chapter 2: Problem set | 101

Lecture 1: Problem Set 1

Lecture 2: Problem 1

Lecture 3: Problem 2

Lecture 4: Problem 3

Lecture 5: Problem Set 2

Lecture 6: Problem 1

Lecture 7: Problem 2

Lecture 8: Problem Set 3

Lecture 9: Problem 1

Lecture 10: Problem 2

Lecture 11: Problem 3 – Method 1

Lecture 12: Problem 3 – Method 2

Chapter 3: Data Structures

Lecture 1: Introduction

Lecture 2: Stacks – Theory

Lecture 3: Stack – Implementations

Lecture 4: Stack – Premitives

Lecture 5: Queues – Theory & Implementation

Lecture 6: Queue – Primitives

Lecture 7: Linked Lists – Singly | Theory & Implementation

Lecture 8: Linked Lists – Singly | Front operations

Lecture 9: Linked Lists – Singly | Back operations

Lecture 10: Linked Lists – doubly | Push operations

Lecture 11: Linked Lists – doubly | Pop Operations

Lecture 12: Binary Trees – Theory & implementation

Lecture 13: Binary Trees – Insertion

Lecture 14: Binary Trees – Printing the tree

Lecture 15: Graph – Theory

Lecture 16: Graph – Representation

Lecture 17: Graph – Implementation

Lecture 18: Heap – Theory

Lecture 19: Heap – Implementation – Insertion

Lecture 20: Heap – Implementation- Extraction

Chapter 4: Problem Set | Data structures

Lecture 1: Problem Set 1

Chapter 5: Algorithms

Lecture 1: Introduction

Lecture 2: Palindromic sequence

Lecture 3: Recursion – Theory

Lecture 4: Recursion – More examples

Lecture 5: Introduction to complexity theory I

Lecture 6: Introduction to complexity theory II

Lecture 7: Counting the occurences – O(n^2) | O(max(n))

Lecture 8: Printing the multiplication table – O(n^2)

Lecture 9: Master theorem| recurense relation complexity

Lecture 10: Bruteforce approach

Chapter 6: Sorting Algorithms

Lecture 1: Bubble sort – O(n^2) | Theory

Lecture 2: Bubble sort – O(n^2) | Implementation

Lecture 3: Bubble sort – O(n^2) | Complexity Analysis

Lecture 4: Selection sort – O(n^2)

Lecture 5: Sorting – Insertion sort – O(n^2)

Lecture 6: Sorting – merge sort – O(n log n) – Theory

Lecture 7: Sorting – merge sort – O(n log n) – Pseudo Code

Lecture 8: Sorting – merge sort – O(n log n) – Implementation

Chapter 7: Graph Algorithms

Lecture 1: Introduction

Lecture 2: Graph – Depth First Search – Theory

Lecture 3: Graph – Depth First Search – Implementation

Lecture 4: Graph – Breadth First Search – Theory

Lecture 5: Graph – Breadth First Search – Implementation

Lecture 6: Graph – Count number of paths between two nodes – Theory

Lecture 7: Graph – Count number of paths between two nodes – Implementation

Lecture 8: Dijkstra's Shortest Path – Theory

Lecture 9: Dijkstra's Shortest Path – Heap Customization

Lecture 10: Dijkstra's Shortest Path – Implementation

Chapter 8: Problem Set | Algorithms

Lecture 1: Problem set 1 – Recursion

Lecture 2: Problem 1

Lecture 3: Problem 2

Lecture 4: Problem 3 – Theory

Lecture 5: Problem 3 – Implementation

Lecture 6: Problem 4

Lecture 7: Problem 5