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.