Basics of DSA
Complexity, arrays, strings and the first data structures. Enough to clear most online assessments.
About Basics of DSA
Data structures are ways of organising data (arrays, linked lists, stacks, queues, hash tables); algorithms are step-by-step methods for solving problems on them, such as searching and sorting. Together they decide whether a program finishes in a millisecond or an hour.
This subject builds the base: measuring cost with Big-O, then the structures and techniques that appear in nearly every online assessment.
Why it matters for placements
The online assessment is the first filter in most placement drives, and it is almost entirely DSA. Clearing it reliably needs these basics done properly.
What you'll learn
8 topics · 29 lessons, each with practice
- Calculate time and space complexity of your own code
- Solve array and string problems with two pointers, sliding window and prefix sums
- Use hashing to turn slow O(n²) solutions into O(n)
- Implement linked lists, stacks and queues, and know when each helps
- Write binary search and the classic sorting algorithms from scratch
- Think recursively and solve basic backtracking problems
Foundation Foundation
Take Foundation testRequired. Enough to clear online assessments and service-company interviews.
Complexity Analysis
Not startedTwo correct solutions can differ hugely in speed once the input has a million elements. Complexity analysis lets you predict that before you run anything, and every interviewer asks for it right after you finish coding.
Arrays
Not startedAn array is the simplest way to store many values of the same type, and it is the input to most coding problems. Knowing what is cheap on an array (reading by index) and what is costly (inserting in the middle) is the base for every later topic.
Strings
Not startedStrings appear in nearly every online assessment, from checking palindromes to comparing words. These problems teach two pointers and frequency counting, two ideas you will reuse across arrays and hashing.
Hashing
Not startedHashing turns many O(n²) brute forces into O(n) solutions by making lookups take constant time on average. HashMap and HashSet are the first tools to try when a problem says "find", "count" or "seen before".
Sorting & Searching
Not startedSorted data is far easier to search, group and compare, and sorting is a classic interview topic. The simple sorts teach how to reason about loops and swaps, and binary search is one of the most reused ideas in coding rounds.
Recursion
Not startedRecursion solves a problem by solving a smaller copy of it, which is the natural fit for trees, backtracking and divide and conquer. Understanding base cases and the call stack now makes those advanced topics much easier.
Interview Ready Interview Ready
Take Interview Ready testRecommended. Enough for technical rounds at good product companies.
Linked List
Not startedA linked list stores elements as nodes joined by references, so inserting or removing at a known node is cheap. Linked list questions are an interview favourite because they test careful pointer handling and the slow and fast pointer trick.
Stack & Queue
Not startedStacks and queues control the order in which items are processed: last in first out, or first in first out. They power undo, bracket matching, function calls and breadth-first search, and they appear in many coding rounds.