DSA Level 1 – Foundations

Explore how data is stored, accessed, and manipulated using arrays and strings. Learn fundamental algorithms and patterns such as the sliding window and two-pointer technique to solve real problems

.

Practice Problems:

• Two Sum Problem
• Maximum Subarray (Kadane’s Algorithm)
• Reverse a string and check palindrome
• Longest Common Prefix

• Array operations (insert, delete, update, traverse)
• String manipulation and searching
• Two-pointer and sliding window techniques
• Prefix sums and subarray problems

Array-Based Student Record System – Implement a system to add, search, and sort student records (by roll number or name) using array operations.

Master the concept of recursion by solving problems through self-calling functions. Discover how backtracking helps explore all possible solutions efficiently.

Practice Problems:

• Factorial and Fibonacci using recursion
• Power calculation (xⁿ) recursively
• N-Queens problem
• Generate all subsets / permutations of an array

• Recursive function design and tracing
• Base cases and recursion trees
• Backtracking patterns (N-Queens, Sudoku, subsets)
• Optimization with pruning techniques

Maze Solver – Create a program to find all possible paths from the start to the destination in a maze using backtracking.

Learn dynamic data storage using linked lists. Understand how nodes are connected and manipulated to efficiently manage memory and sequential data.

Practice Problems:

• Reverse a linked list
• Detect a cycle in a linked list
• Merge two sorted linked lists
• Find the middle element of a linked list

• Implementing singly and doubly linked lists
• Insertion, deletion, and reversal operations
• Loop detection and merging techniques
• Understanding memory management and pointers

Music Playlist Manager – Build a program that simulates a music playlist using linked lists with operations like add, remove, and next/previous song navigation.

Understand how stacks and queues organize data linearly for tasks like undo-redo, parsing, and scheduling. Learn both array-based and linked implementations.

Practice Problems:

• Valid Parentheses problem
• Evaluate Postfix Expression
• Implement Queue using Stacks
• Stock Span Problem

• Stack & Queue implementation
• Prefix/infix/postfix expression evaluation
• Balanced parentheses & stock span problems
• Circular queue and deque operations

Expression Evaluator – Build a calculator that converts an infix mathematical expression to postfix and evaluates the result using stacks.

Step into hierarchical data structures — learn about binary trees and binary search trees (BST). Understand traversals and basic operations that form the backbone of advanced trees.

Practice Problems:

• Inorder, Preorder, and Postorder Traversal
• Level Order Traversal (using Queue)
• Find Height of Binary Tree
• Lowest Common Ancestor (LCA) in BST

• Binary Tree & BST creation and traversal
• Recursive and iterative traversal techniques
• Searching, insertion, and deletion in BST
• Tree height, leaf count, and path sum problems

Mini Project:

Family Tree Builder – Build a simple binary tree to represent family relationships and display different traversal views (preorder, inorder, postorder).

Study fundamental searching and sorting techniques used in every software system. Implement and compare algorithms based on their complexity and use cases.

Practice Problems:

• Binary Search implementation
• Merge Sort and Quick Sort
• Sort an array of 0s, 1s, and 2s (Dutch National Flag)
• Find Kth smallest/largest element

• Linear and Binary Search
• Bubble, Selection, Insertion Sort
• Merge Sort and Quick Sort
• Divide and Conquer techniques
• Sorting algorithm performance comparison

Mini Project:

Sorting Visualizer (Console Version) – Create a console app that visualizes sorting steps (for Bubble, Insertion, and Merge Sort) with time comparison.