Week 1: Introduction to Data Structures and Algorithms
Lecture Topics
Importance of Data Structures in Programming.
Algorithm complexity: Time and Space.
Big-O notation: Introduction and examples.
Learning Objectives
Explain the role of data structures in solving computational problems.
Analyze simple algorithms using Big-O notation.
Lecture Activities
Instructor-led discussion: Examples of algorithm performance.
Group activity: Compare the efficiency of different sorting methods (e.g.,
bubble sort vs insertion sort).
Laboratory Activity
Install Python and set up a coding environment (e.g., Jupyter Notebook/IDLE).
Write Python scripts to calculate factorial iteratively and recursively.
Measure the runtime of both approaches using Python’s time module.
Output: Python programs and runtime comparison analysis.
Week 2: Arrays and Strings
Lecture Topics
Array operations: Insertion, deletion, traversal.
String manipulation in Python: slicing, searching, and formatting.
Learning Objectives
Implement basic operations on arrays and strings.
Solve computational problems using arrays and strings.
Lecture Activities
Solve examples of array-based problems like finding the largest element or
reversing an array.
Interactive coding demonstration: Manipulating strings in Python.
Laboratory Activity
Write Python programs to:
Find the largest and smallest elements in an array.
Count occurrences of a specific character in a string.
Check if a string is a palindrome.
Output: Python scripts for the given problems.
Week 3: Linked Lists
Lecture Topics
Concepts: Nodes, singly, doubly, and circular linked lists.
Basic operations: Insertion, deletion, and traversal.
Learning Objectives
Construct linked list data structures in Python.
Perform basic linked list operations.
Lecture Activities
Create a diagram of a linked list.
Walkthrough: Python implementation of a singly linked list.
Laboratory Activity
Implement a singly linked list class in Python with methods for insertion,
deletion, and traversal.
Enhance the class to create a doubly linked list.
Output: Python classes for singly and doubly linked lists.
Week 4: Stacks
Lecture Topics
Definition and applications: Balancing parentheses, undo functionality.
Stack implementation using arrays and linked lists.
Learning Objectives
Construct stack data structures in Python.
Apply stacks to solve computational problems.
Lecture Activities
Discuss real-world applications of stacks.
Code a stack implementation using lists in Python.
Laboratory Activity
Implement a stack using both arrays (Python lists) and linked lists.
Solve a problem to validate balanced parentheses using a stack.
Output: Python implementations of stacks and problem solutions.
Week 5: Queues
Lecture Topics
Types: Simple queue, circular queue, and deque.
Queue implementation using arrays and linked lists.
Learning Objectives
Construct queue data structures in Python.
Use queues in real-world problem-solving.
Lecture Activities
Discuss real-world queue applications (e.g., scheduling systems).
Implement a queue using Python lists.
Laboratory Activity
Implement a circular queue using Python.
Simulate a simple ticketing system using a queue.
Output: Python implementations of queues.
Week 6: Recursion
Lecture Topics
Concept of recursion.
Recursive algorithms: Factorial, Fibonacci, Towers of Hanoi.
Learning Objectives
Write and debug recursive Python programs.
Understand and solve problems using recursive algorithms.
Lecture Activities
Solve the Fibonacci sequence recursively.
Discuss the stack behavior during recursion.
Laboratory Activity
Write Python programs for:
Fibonacci sequence generation.
Towers of Hanoi simulation.
Output: Recursive solutions in Python.
Week 7: Trees
Lecture Topics
Binary trees: Representation and traversal.
Binary Search Trees (BST): Insertion, deletion, search.
Learning Objectives
Construct and traverse binary trees in Python.
Solve problems using binary search trees.
Lecture Activities
Code walkthrough: Binary tree class implementation in Python.
Discuss traversal techniques (preorder, inorder, postorder).
Laboratory Activity
Write Python code to:
Build a binary tree and perform traversals.
Create a BST and search for an element.
Output: Python implementations of tree traversals and BST operations.
Week 8: Sorting Algorithms
Lecture Topics
Sorting techniques: Bubble sort, insertion sort, merge sort, quicksort.
Analysis of sorting algorithms.
Learning Objectives
Implement and compare sorting algorithms in Python.
Analyze the time complexity of sorting algorithms.
Laboratory Activity
Write Python programs to:
Implement sorting algorithms.
Compare their performance on different datasets.
Output: Python scripts for sorting algorithms with runtime analysis.
Week 9: Searching Algorithms
Lecture Topics
Linear search and binary search.
Application of searching in real-world problems.
Learning Objectives
Implement searching algorithms in Python.
Analyze their time complexity.
Laboratory Activity
Implement linear and binary search algorithms in Python.
Solve a problem to find elements in a large dataset.
Output: Python scripts for searching algorithms.
Week 10: Graphs
Lecture Topics
Graph representation: Adjacency list and adjacency matrix.
Graph traversal: BFS and DFS.
Learning Objectives
Implement graph structures in Python.
Traverse graphs using BFS and DFS.
Laboratory Activity
Implement BFS and DFS in Python.
Solve a graph traversal problem (e.g., shortest path).
Output: Python scripts for BFS and DFS.
Week 11: Dynamic Programming
Lecture Topics
Introduction to dynamic programming.
Examples: Longest Common Subsequence, Knapsack problem.
Learning Objectives
Solve optimization problems using dynamic programming.
Laboratory Activity
Solve the knapsack problem using Python.
Write a program to find the longest common subsequence of two strings.
Output: Python solutions for dynamic programming problems.
