C Programming, C++ & Data Structures and Algorithms Course

• Variables 

• Variable Declaration and Initialization 

• Rules for Naming Variables 

• Constants 

• Literals 

• Basic Data Types 

• int 

• char 

• float 

• double 

• void 

• Type Modifiers 

• short 

• long 

• signed 

• unsigned 

• Size and Range of Data Types 

• sizeof Operator 

• Type Conversion 

• Implicit Type Conversion 

• Explicit Type Conversion 

• Type Casting 

• const Keyword 

• Symbolic Constants using #define 

• Standard Input and Output 

• printf() 

• scanf() 

• Format Specifiers 

• Escape Sequences 

• Character Input and Output 

• getchar() 

• putchar() 

• String Input and Output 

• fgets() 

• puts() 

• Formatted Input and Output 

• Arithmetic Operators 

• Relational Operators 

• Logical Operators 

• Assignment Operators 

• Increment and Decrement Operators 

• Bitwise Operators 

• Bitwise AND 

• Bitwise OR 

• Bitwise XOR 

• Bitwise NOT 

• Left Shift 

• Right Shift 

• Conditional/Ternary Operator 

• sizeof Operator 

• Comma Operator 

• Expressions 

• Operator Precedence 

• Operator Associativity 

• Type Conversion in Expressions 

• Introduction to Control Flow 

• if Statement 

• if-else Statement 

• Nested if-else 

• else-if Ladder 

• Multiple Conditions 

• switch Statement 

• break Statement 

• Nested switch 

• Conditional/Ternary Operator 

• Comparison of if-else and switch 

• Introduction to Iteration 

• while Loop 

• do-while Loop 

• for Loop 

• Nested Loops 

• break 

• continue 

• goto 

• Loop Control and Execution Flow 

One-Dimensional Arrays 

• Introduction to Arrays 

• Array Declaration 

• Array Initialization 

• Array Input and Output 

• Array Traversal 

• Accessing and Updating Elements 

• Passing Arrays to Functions 

• Basic Array Operations 

• Sum and Average 

• Maximum and Minimum 

• Reversing an Array 

• Copying Arrays 

• Element Frequency 

• Insertion 

• Deletion 

Two-Dimensional Arrays 

• Introduction to Two-Dimensional Arrays 

• Declaration and Initialization 

• Matrix Representation 

• Matrix Input and Output 

• Row and Column Traversal 

• Matrix Addition 

• Matrix Subtraction 

• Matrix Multiplication 

• Matrix Transpose 

• Diagonal Operations 

Multidimensional Arrays 

• Introduction to Multidimensional Arrays 

• Basic Memory Representation 

• Introduction to Strings 

• Character Arrays 

• Null Character (‘\0’) 

• String Declaration and Initialization 

• String Input and Output 

• String Traversal 

• Standard String Library (string.h) 

String Functions 

• strlen() 

• strcpy() 

• strcat() 

• strcmp() 

String Programming 

• Finding String Length 

• Copying a String 

• Comparing Strings 

• Concatenating Strings 

• Reversing a String 

• Palindrome Checking 

• Counting Characters 

• Counting Vowels and Consonants 

• Word Counting 

• Character Frequency 

• Uppercase and Lowercase Conversion

• Introduction to Functions 

• Advantages of Functions 

• Function Declaration 

• Function Definition 

• Function Call 

• Function Prototype 

• Return Type 

• Parameters and Arguments 

• Formal Parameters 

• Actual Parameters 

• Return Statement 

Types of Functions 

• No Arguments and No Return Value 

• Arguments and No Return Value 

• No Arguments and Return Value 

• Arguments and Return Value 

Parameter Passing 

• Call by Value 

• Passing Addresses to Functions 

• Passing Arrays to Functions 

• Passing Strings to Functions 

Additional Concepts 

• Nested Function Calls 

• Scope of Variables 

• Local Variables 

• Global Variables 

• Introduction to Recursion 

• Recursive Functions 

• Base Condition 

• Recursive Call 

• Function Call Stack 

• Direct Recursion 

• Recursion vs Iteration 

Recursive Programming 

• Factorial 

• Fibonacci Series 

• Sum of Natural Numbers 

• Power Calculation 

• Sum of Digits 

• GCD 

• Basic Recursive Problems 

• Scope and Lifetime of Variables 

• Storage Classes in C 

• auto 

• register 

• static 

• extern 

• Local and Global Scope 

• Static Variables 

• External Variables 

• Introduction to Memory Addresses 

• Introduction to Pointers 

• Pointer Declaration 

• Pointer Initialization 

• Address Operator (&) 

• Dereference Operator (*) 

• Accessing Values Through Pointers 

• NULL Pointer 

• Pointer Arithmetic 

• Increment and Decrement of Pointers 

• Pointer Comparison 

• Pointer to Pointer 

Pointers and Arrays 

• Relationship Between Arrays and Pointers 

• Array Traversal Using Pointers 

• Pointer Arithmetic with Arrays 

Pointers and Strings 

• Character Pointers 

• String Traversal Using Pointers 

Pointers and Functions 

• Passing Pointers to Functions 

• Modifying Variables Through Pointers 

• Passing Arrays Through Pointers 

• Introduction to Structures 

• Structure Declaration 

• Structure Variables 

• Structure Initialization 

• Accessing Structure Members 

• Array of Structures 

• Nested Structures 

• Passing Structures to Functions 

• Returning Structures from Functions 

• Pointer to Structure 

• Arrow Operator (->) 

• typedef 

Unions 

• Introduction to Unions 

• Union Declaration 

• Union Variables 

• Accessing Union Members 

• Memory Allocation in Union 

• Structure vs Union 

Enumerations 

• Introduction to enum 

• Declaring Enumerated Data Types 

• Using Enumeration Constants 

• Introduction to Memory Management 

• Static Memory Allocation 

• Dynamic Memory Allocation 

• Stack and Heap Memory 

• Dynamic Memory Allocation using <stdlib.h> 

Memory Management Functions 

• malloc() 

• calloc() 

• realloc() 

• free() 

Concepts 

• Dynamic Arrays 

• Memory Deallocation 

• Memory Leaks 

• Dangling Pointers 

• NULL Pointer Handling

• Introduction to C Preprocessor 

• Preprocessor Directives 

• #include 

• #define 

• Symbolic Constants 

• Macros 

• Function-Like Macros 

Conditional Compilation 

• #if 

• #ifdef 

• #ifndef 

• #else 

• #endif 

Header Files 

• Standard Header Files 

• User-Defined Header Files 

• Header Guards 

• Introduction to File Handling 

• File Pointer 

• FILE Data Type 

• Opening Files 

• Closing Files 

File Opening Modes 

• Read Mode 

• Write Mode 

• Append Mode 

• Read/Write Modes 

• Binary Modes 

File Handling Functions 

• fopen() 

• fclose() 

• fgetc() 

• fputc() 

• fgets() 

• fputs() 

• fprintf() 

• fscanf() 

• fread() 

• fwrite() 

Additional Concepts 

• End of File (EOF) 

• Text Files 

• Binary Files 

• Sequential File Access 

• Reading and Writing Structures to Files 

Command-Line Arguments 

• Introduction to Command-Line Arguments 

• argc 

• argv 

• Passing Values from Command Line 

Modular Programming 

• Introduction to Modular Programming 

• Creating Multiple Source Files 

• User-Defined Header Files 

• Function Declarations in Header Files 

• Separate Function Implementations 

• External Variables 

• extern Keyword 

• Compiling and Linking Multiple Files 

• Introduction to C++ 

• History and Evolution of C++ 

• Features of C++ 

• Applications of C++ 

• Structure of a C++ Program 

• Compilation and Execution 

• Header Files 

• iostream 

• namespace 

• std Namespace 

• main() Function 

• cin 

• cout 

• endl 

• Scope Resolution Operator 

• Reference Variables 

• bool Data Type 

• string Data Type 

• auto Keyword 

• Type Casting 

• Default Arguments 

• Inline Functions 

• Introduction to Function Overloading 

• Procedural Programming vs Object-Oriented Programming 

• Program Structure 

• Functions vs Classes and Objects 

• Data Hiding 

• Input and Output 

• Dynamic Memory Management 

• Function Overloading 

• Operator Overloading 

• References 

• Structures in C and C++ 

• Exception Handling 

• Generic Programming 

• Standard Library 

• Templates 

• STL 

• Namespaces

• Stack Memory 

• Heap Memory 

• Static Memory Allocation 

• Dynamic Memory Allocation 

• new 

• delete 

• new[] 

• delete[] 

• Dynamic Variables 

• Dynamic Arrays 

• Dynamic 2D Arrays 

• Dynamic Objects 

• Dynamic Arrays of Objects 

• NULL 

• nullptr 

• Memory Leaks 

• Dangling Pointers 

• Memory Deallocation 

• C vs C++ Dynamic Memory Management 

• Introduction to OOP 

• Procedural Programming vs OOP 

• Need for OOP 

• Classes 

• Objects 

• Encapsulation 

• Abstraction 

• Inheritance 

• Polymorphism 

• Advantages of OOP 

• Class Declaration 

• Object Creation 

• Data Members 

• Member Functions 

• Access Specifiers 

• public 

• private 

• protected 

• Member Functions Inside Class 

• Member Functions Outside Class 

• Scope Resolution Operator 

• Multiple Objects 

• Array of Objects 

• Objects as Function Arguments 

• Returning Objects from Functions 

Constructors 

• Default Constructor 

• Parameterized Constructor 

• Copy Constructor 

• Constructor Overloading 

• Constructor with Default Arguments 

• Dynamic Constructor 

• Initialization List 

Destructors 

• Destructor Syntax 

• Destructor Execution 

• Memory Cleanup 

• Constructor and Destructor Calling Order 

Encapsulation 

• Data Binding 

• Data Hiding 

• Access Control 

• Getter Functions 

• Setter Functions 

Abstraction 

• Implementation Hiding 

• Interface-Based Design 

• Encapsulation vs Abstraction 

• Base Class 

• Derived Class 

• Single Inheritance 

• Multilevel Inheritance 

• Multiple Inheritance 

• Hierarchical Inheritance 

• Hybrid Inheritance 

• Public Inheritance 

• Private Inheritance 

• Protected Inheritance 

• Constructor in Inheritance 

• Destructor in Inheritance 

• Function Overriding 

• Ambiguity in Multiple Inheritance 

• Scope Resolution in Inheritance 

Compile-Time Polymorphism 

• Function Overloading 

• Constructor Overloading 

• Operator Overloading 

Runtime Polymorphism 

• Function Overriding 

• Base Class Pointer 

• Derived Class Object 

• Virtual Functions 

• Pure Virtual Functions 

• Abstract Classes 

• Late Binding 

• Dynamic Binding 

• this Pointer 

• Static Data Members 

• Static Member Functions 

• Friend Functions 

• Friend Classes 

• Constant Objects 

• Constant Member Functions 

• Object Pointers 

• Dynamic Objects 

• Shallow Copy 

• Deep Copy 

• Copy Constructor 

• Introduction to Exception Handling 

• try 

• catch 

• throw 

Function Templates 

• Function Template Syntax 

• Generic Functions 

• Template Function Calls 

• Multiple Template Parameters 

• Function Template Overloading 

Class Templates 

• Class Template Syntax 

• Template Objects 

• Multiple Template Parameters 

• Template Member Functions 

• Generic Classes 

• Introduction to STL 

• Need for STL 

• Components of STL 

• Containers 

• Iterators 

• Algorithms 

• Function Objects 

• Utility Components 

Vector 

• Declaration and Initialization 

• push_back() 

• pop_back() 

• size() 

• capacity() 

• empty() 

• at() 

• front() 

• back() 

• insert() 

• erase() 

• clear() 

• Traversal 

Array 

• std::array 

• Initialization 

• Element Access 

• Traversal 

List 

• std::list 

• push_front() 

• push_back() 

• pop_front() 

• pop_back() 

• insert() 

• erase() 

• Traversal 

Forward List 

• std::forward_list 

• Basic Operations 

Deque 

• std::deque 

• Front Operations 

• Back Operations 

• Insertion 

• Deletion 

Stack 

• LIFO 

• push() 

• pop() 

• top() 

• empty() 

• size() 

Queue 

• FIFO 

• push() 

• pop() 

• front() 

• back() 

• empty() 

• size() 

Priority Queue 

• Max Heap 

• Min Heap 

• push() 

• pop() 

• top() 

• Comparator

Set 

• Ordered Storage 

• Unique Elements 

• Insertion 

• Deletion 

• find() 

• count() 

Multiset 

• Ordered Storage 

• Duplicate Elements 

Map 

• Key-Value Pairs 

• Ordered Keys 

• Insertion 

• Updating 

• Searching 

• Traversal 

Multimap 

• Duplicate Keys 

• Key-Value Storage 

Unordered Set 

• Hash-Based Storage 

• Insertion 

• Deletion 

• Searching 

Unordered Map 

• Key-Value Storage 

• Hashing 

• Insertion 

• Updating 

• Searching 

• Traversal 

Comparison 

• set vs unordered_set 

• map vs unordered_map 

• Introduction to Iterators 

• begin() 

• end() 

• rbegin() 

• rend() 

• Input Iterator 

• Output Iterator 

• Forward Iterator 

• Bidirectional Iterator 

• Random Access Iterator 

• Iterator Traversal 

• Iterator Dereferencing 

• sort() 

• reverse() 

• find() 

• count() 

• min() 

• max() 

• min_element() 

• max_element() 

• binary_search() 

• lower_bound() 

• upper_bound() 

• swap() 

• next_permutation() 

• prev_permutation() 

• accumulate() 

• fill() 

• copy() 

• unique() 

Pair 

• pair 

• first 

• second 

• Nested Pair 

• Pair with Containers 

Comparator 

• Default Comparator 

• Custom Comparator 

• Ascending Order 

• Descending Order 

• Comparator with Objects 

• Comparator with Priority Queue 

Lambda 

• Lambda Syntax 

• Lambda Expressions 

• Lambda with STL Algorithms 

• Custom Sorting using Lambda 

• Introduction to Data Structures 

• Introduction to Algorithms 

• Need for Data Structures 

• Need for Algorithms 

• Types of Data Structures 

• Linear Data Structures 

• Non-Linear Data Structures 

• Primitive and Non-Primitive Data Structures 

• Static and Dynamic Data Structures 

• Abstract Data Types 

• Problem-Solving Approach 

• Choosing an Appropriate Data Structure 

• Introduction to Algorithm Analysis 

• Time Complexity 

• Space Complexity 

• Best Case 

• Average Case 

• Worst Case 

• Asymptotic Notations 

• Big O Notation 

• Omega Notation 

• Theta Notation 

• Common Time Complexities 

• O(1) 

• O(log n) 

• O(n) 

• O(n log n) 

• O(n²) 

• Complexity of Loops 

• Complexity of Nested Loops 

• Basic Complexity of Recursive Functions 

• Comparison of Algorithms Based on Complexity 

• Array Representation 

• Array Traversal 

• Accessing Elements 

• Updating Elements 

• Insertion 

• Deletion 

• Reversing an Array 

• Finding Maximum and Minimum 

• Finding Second Largest Element 

• Frequency of Elements 

• Duplicate Elements 

• Removing Duplicates 

• Rotating an Array 

• Merging Arrays 

• Basic Array Problem Solving 

• 2D Array Representation 

• Row-Wise Traversal 

• Column-Wise Traversal 

• Matrix Traversal 

• Diagonal Traversal 

• Matrix Transpose 

• Matrix Rotation Basics 

• Searching in a Matrix 

• Basic Matrix Problems 

• String Representation in C++ 

• String Traversal 

• Character Frequency 

• String Reverse 

• Palindrome String 

• Anagram Basics 

• Removing Duplicate Characters 

• Counting Characters 

• Counting Words 

• String Comparison 

• Substrings 

• Basic String Manipulation 

• Basic String Problems 

Linear Search 

• Introduction to Linear Search 

• Linear Search Algorithm 

• Linear Search Implementation 

• Time Complexity 

• Space Complexity 

Binary Search 

• Introduction to Binary Search 

• Prerequisites for Binary Search 

• Iterative Binary Search 

• Recursive Binary Search 

• First Occurrence 

• Last Occurrence 

• Count of Occurrences 

• Lower Bound 

• Upper Bound 

• Time Complexity 

• Space Complexity 

Bubble Sort 

• Bubble Sort Algorithm 

• Working of Bubble Sort 

• Optimized Bubble Sort 

• Time Complexity 

• Space Complexity 

Selection Sort 

• Selection Sort Algorithm 

• Working of Selection Sort 

• Time Complexity 

• Space Complexity 

Insertion Sort 

• Insertion Sort Algorithm 

• Working of Insertion Sort 

• Time Complexity 

• Space Complexity 

Merge Sort 

• Divide and Conquer 

• Merge Operation 

• Merge Sort Algorithm 

• Recursive Implementation 

• Time Complexity 

• Space Complexity 

Quick Sort 

• Divide and Conquer 

• Pivot Element 

• Partitioning 

• Quick Sort Algorithm 

• Recursive Implementation 

• Time Complexity 

• Space Complexity 

Sorting Comparison 

• Comparison of Sorting Algorithms 

• Stable and Unstable Sorting 

• In-Place and Out-of-Place Sorting 

• Recursion Review 

• Base Case 

• Recursive Case 

• Recursive Call Stack 

• Recursive Tree Basics 

• Factorial Using Recursion 

• Fibonacci Using Recursion 

• Sum of Natural Numbers 

• Sum of Array Elements 

• Reverse an Array 

• Reverse a String 

• Palindrome Using Recursion 

• Binary Search Using Recursion 

• Basic Recursive Problem Solving

• Introduction to Linked List 

• Need for Linked List 

• Array vs Linked List 

• Node Structure 

• Dynamic Node Creation 

• Head Pointer 

• Tail Pointer 

• Linked List Traversal 

• Displaying Linked List 

• Counting Nodes 

• Searching an Element 

• Updating Node Data 

Insertion 

• Insertion at Head 

• Insertion at Tail 

• Insertion at a Given Position 

Deletion 

• Deletion from Head 

• Deletion from Tail 

• Deletion from a Given Position 

• Deletion by Value 

Linked List Operations 

• Reversing a Linked List 

• Finding Middle Element 

• Basic Linked List Problems 

• Introduction to Stack 

• LIFO Principle 

• Stack Operations 

• Push 

• Pop 

• Peek / Top 

• isEmpty 

• Size 

• Stack Implementation Using Array 

• Stack Implementation Using Singly Linked List 

• Stack Using STL 

• Stack Overflow 

• Stack Underflow 

Applications of Stack 

• Reverse a String 

• Balanced Parentheses 

• Expression Basics 

• Infix Expression 

• Prefix Expression 

• Postfix Expression 

• Infix to Postfix Conversion 

• Infix to Prefix Conversion 

• Postfix Evaluation 

• Basic Stack Problems 

• Introduction to Queue 

• FIFO Principle 

• Queue Operations 

• Enqueue 

• Dequeue 

• Front 

• Rear 

• isEmpty 

• Size 

• Queue Implementation Using Array 

• Queue Implementation Using Singly Linked List 

• Queue Using STL 

• Queue Overflow 

• Queue Underflow 

Circular Queue 

• Introduction to Circular Queue 

• Need for Circular Queue 

• Circular Queue Representation 

• Enqueue Operation 

• Dequeue Operation 

• Front and Rear Management 

Deque 

• Introduction to Double-Ended Queue 

• Insertion from Front 

• Insertion from Rear 

• Deletion from Front 

• Deletion from Rear 

• Deque Using STL 

• Brute Force Approach 

• Optimized Approach 

• Array Traversal Techniques 

• Frequency Counting 

• Prefix Sum Basics 

• Two Pointer Technique 

• Basic Sliding Window 

• Sorting-Based Problem Solving 

• Binary Search-Based Problem Solving 

• Recursion-Based Problem Solving 

• Linked List-Based Problem Solving 

• Stack-Based Problem Solving 

• Queue-Based Problem Solving 

• vector 

• pair 

• stack 

• queue 

• deque 

• sort() 

• reverse() 

• find() 

• binary_search() 

• lower_bound() 

• upper_bound() 

• min_element() 

• max_element() 

• Basic Custom Comparator 

• Selecting Appropriate STL Containers 

After completing the Data Structures & Algorithms module, students will be able to: 

1. Understand fundamental data structures and evaluate basic time and space complexity.
2. Apply arrays, two-dimensional arrays and strings to solve beginner-to-intermediate programming problems.
3. Implement and compare linear search, binary search and fundamental sorting algorithms.
4. Use recursion to solve basic algorithmic problems and understand recursive execution flow.
5. Implement and perform core operations on a Singly Linked List.
6. Implement Stack and Queue data structures using arrays, linked lists and STL.
7. Apply basic problem-solving techniques such as brute force, prefix sum, two pointers and sliding window.
8. Use appropriate C++ STL utilities to write clear and efficient DSA solutions.