DSA in 30 Days: Series Index

DSA in 30 Days is a TechVani series for BTech CSE students. It covers 30 topics in 10 episodes. Each episode has written notes here, with worked examples and practice questions, and a matching video when its link is available.

Read the notes first, try the practice questions, then watch the matching video when available to check your understanding. Each episode page links to the next one.

Episodes

1. Episode 1: Complexity, arrays and recursion (live)
2. Episode 2: Linear and sentinel search, bubble, selection and insertion sort (live)
3. Episode 3: Merge sort, quick sort, counting and radix sort (live)
4. Episode 4: Stack, postfix evaluation and circular queue (live)
5. Episode 5: Linked lists, insertion, deletion and reversal (live)
6. Episode 6: Trees, BST, AVL and LCA (live)
7. Episode 7: Heaps, priority queues, hashing and collisions (live)
8. Episode 8: Graphs: BFS, DFS, Dijkstra, MST, topological sort (live)
9. Episode 9: Greedy and dynamic programming (live)
10. Episode 10: Backtracking and the final revision sheet (live)

How this series works

The 30 topics follow one path: first how to measure a program, then the basic tools (arrays, searching, sorting), then structures that store data in a shape (stack, queue, linked list, tree, heap, hash table, graph), and last the methods for hard problems (greedy, dynamic programming, backtracking). Each step uses the one before it, so follow the order.

What each episode teaches, in one line

• Episode 1: how to count the work a program does, how arrays are stored, and how a function calls itself.
• Episode 2: how to find an item in a list and how to put a list in order with simple sorts.
• Episode 3: faster sorts that split the list (merge sort, quick sort) and sorts that count (counting sort, radix sort).
• Episode 4: stack (last in, first out) and queue (first in, first out), with postfix evaluation.
• Episode 5: linked lists, where each item points to the next.
• Episode 6: trees, binary search trees, balanced AVL trees and the lowest common ancestor.
• Episode 7: heaps for the biggest or smallest item, and hashing for fast lookup.
• Episode 8: graphs: ways to visit nodes, shortest paths, spanning trees and ordering tasks.
• Episode 9: greedy choices and dynamic programming.
• Episode 10: backtracking, then a revision sheet for the whole series.

Worked example: why complexity matters

Count the steps for a list of n items. A method that takes about n × n steps does 100 steps for n = 10, 10,000 for n = 100 and 1,000,000 for n = 1,000. A method that takes about n × log₂n steps does about 33 steps for n = 10, 664 for n = 100 and 9,966 for n = 1,000. Both give a sorted list, but at n = 1,000 the first does about 100 times more work. Episode 1 explains how to read this, and Episodes 2 and 3 show the two kinds of sort.

How to study with this series

1. Read the episode notes first and write the definition of each topic in your own words.
2. Solve the practice questions before you look at the answers.
3. Watch the matching video when available to check what you missed.
4. Write each algorithm again from memory the next day.

Questions this series can answer

Do I need to know C or Python first? Basic programming helps, but each note explains the steps in words before code. Is it the official syllabus? No. Check your own college course outline. Where do I practise code? Use the Online Compiler and the Lab Files section.

Already live

Binary Search explained, with tested code and practice is the pilot lesson of this series.

More study help

Exam Numericals Hub | BTech CSE Exam Notes | Home