DSA: Learning Path from Arrays to Graphs
0:000:00
From Arrays to Graphs: What to Learn in DSA & Beyond
📘 A Ranked Learning Table for DS, Algorithms, and CS Concepts
# Newly added for completeness and coverage of foundational topics.
| Data Structures | Algorithms (Part 1) | Algorithms (Part 2) | Other (Concepts) | Tools/Systems |
|---|---|---|---|---|
| Array | Sorting | Counting Sort | Math | Shell |
| String | Counting | Line Sweep | Design | Database |
| Stack | Two Pointers | Bucket Sort | Brainteaser | Interactive |
| Queue | Prefix Sum | Shortest Path | Geometry | Concurrency |
| Linked List | Sliding Window | Combinatorics | Probability and Statistics | Command Line Tools # |
| Hash Table | Recursion | Rolling Hash | Game Theory | Version Control (Git) # |
| Set | Binary Search | Reservoir Sampling | Randomized | Operating Systems Basics # |
| Matrix | Bit Manipulation | Minimum Spanning Tree | Computational Complexity # | Networking Basics (TCP/IP) # |
| Binary Tree | Greedy | Strongly Connected Component | Memory Models # | HTTP / DNS / Web Basics # |
| Tree | Simulation | Eulerian Circuit | Distributed Systems # | Security Basics (Hashing, etc) # |
| Doubly-Linked List | Depth-First Search (DFS) | Radix Sort | Machine Learning Basics # | Compilers and Parsing # |
| Ordered Set | Breadth-First Search (BFS) | Rejection Sampling | Cryptography # | Software Engineering Principles # |
| Heap (Priority Queue) | Backtracking | Biconnected Component | ||
| Trie | Divide and Conquer | KMP Algorithm # | ||
| Union Find | Dynamic Programming | Z-Algorithm # | ||
| Binary Search Tree | Memoization | Network Flow (Ford-Fulkerson) # | ||
| Hash Function | String Matching | Convex Hull Algorithm # | ||
| Segment Tree | Enumeration | Maximum Bipartite Matching # | ||
| Binary Indexed Tree | Number Theory | Linear Programming # | ||
| Suffix Array | Bitmask | Fast Fourier Transform (FFT) # | ||
| Monotonic Stack | Topological Sort | |||
| Monotonic Queue | Merge Sort | |||
| Data Stream | Quickselect | |||
| Iterator | ||||
| Graph | ||||
| Skip List # | ||||
| Deque # | ||||
| Bloom Filter # |
Full table
From Arrays to Graphs: What to Learn in DSA & Beyond
📘 A Ranked (Easy on Top to Hard at bottom) Learning Table for Data Structures, Algorithms, CS Concepts, and Tools
# Newly added for completeness and coverage of foundational topics.
| Data Structures | Algorithms | Core CS Concepts | Tools/Systems |
|---|---|---|---|
| Array | Linear Search | Primitive Data Types | Shell / Command Line Basics |
| String | Basic Array Operations | Math (Arithmetic, Basic Algebra) | Programming Language(s) (Pick One) |
| Stack | String Manipulation Basics | Time/Space Complexity (Big O) | IDE / Text Editor |
| Queue | Palindrome Checking | Abstract Data Types (ADT) | Debugger / REPLs |
| Deque | Push, Pop, Peek Operations | Pointers / References | Version Control (Git) |
| Linked List | Enqueue, Dequeue Operations | OOP Basics (Classes, Objects) | Markdown / Basic Documentation |
| Doubly-Linked List | Add/Remove Front/Back | Recursion | Testing Basics (Unit Tests) |
| Hash Table | Parentheses Matching | Hash Function | API Basics (What is an API?) |
| Set | Traversal, Insertion, Deletion (Linked List) | Algorithm Design Paradigms (Intro) (e.g., Brute Force) | Operating Systems Basics |
| Matrix | Reversing a Linked List | Discrete Math Basics (Sets, Logic) | Networking Basics (TCP/IP, HTTP, DNS) |
| Tree (General Concept) | Bidirectional Operations (Doubly LL) | Memory Models (Stack, Heap) | Web Basics (Client-Server) |
| Binary Tree | Insert, Delete, Search (Hash Table) | Graph Theory Basics | Database (Relational, SQL Intro) |
| Binary Search Tree (BST) | Two Sum Problem / Anagrams | Greedy Algorithms (Intro) | Security Basics (e.g., Hashing) |
| Heap (Priority Queue) | Add, Remove, Contains (Set) | Divide and Conquer | Command Line Tools (grep, find, awk, sed etc.) |
| Graph | Finding Duplicates | Dynamic Programming (Concept of Memoization/Tabulation) | Software Engineering Principles (DRY, KISS, SOLID) |
| Union Find | Matrix Traversal, Transposition | Pathfinding Concepts | Concurrency (Threads, Mutexes, Processes) |
| Ordered Set (concept, often via Balanced BST) | Spiral Traversal | Amortized Analysis | REST APIs (Design, Implementation) |
| Trie | Recursion (for Tree Traversal) | Randomized (Algorithms Concept) | Compilers and Parsing |
| Monotonic Stack | Tree Traversals (Pre, In, Post) | Bitmask (with DP) | Distributed Systems (Concepts: CAP Theorem, etc.) |
| Monotonic Queue | Tree Construction from Traversals | Iterator Pattern | Cloud Computing (IaaS, PaaS, SaaS, Basic Services) |
| AVL Tree | Tree Diameter / Height | String Matching (Concept) | Containerization (e.g., Docker) |
| Red-Black Tree | Search, Insert, Delete in BST | Combinatorics | CI/CD Tools (e.g., Jenkins, GitHub Actions) |
| Segment Tree | Validate BST / LCA in BST | Probability and Statistics | System Design (Advanced: Scalability, Microservices, etc.) |
| Binary Indexed Tree (BIT) | Heapify, Insert, Extract-Min/Max | Number Theory (GCD, Primes, Modulo) | Advanced Security Concepts (Encryption, AuthN/AuthZ deeper dive) |
| Suffix Array | Graph Representation | Computational Complexity (P vs NP, NP-Completeness) | Web APIs (Advanced: GraphQL, gRPC, WebSockets) |
| Skip List | Basic Sorting (Bubble, Insertion) | Data Stream (Concept/Problem Type) | |
| Bloom Filter | Binary Search (on sorted array) | Caching Strategies | |
| B-Tree / B+Tree | Two Pointers | Information Theory | |
| LRU Cache (as a structure combining others) | Sliding Window | Data Compression | |
| Suffix Tree (often learned with Suffix Arrays but more complex) | Prefix Sum | Cryptography | |
| Bit Manipulation | Geometric Algorithms (Line Sweep, Convex Hull Concepts) | ||
| Breadth-First Search (BFS) | Probabilistic Data Structures (Concept) | ||
| Depth-First Search (DFS) | Suffix Tree (DS Concept) | ||
| Merge Sort | Machine Learning Basics | ||
| Quick Sort | AI/ML Algorithms (General concept of their existence/types) | ||
| Heap Sort | Deep Learning (Intro) | ||
| Quickselect | Quantum Computing (Intro) | ||
| Sliding Window Min/Max (Intro) | Sustainability (in Computing) | ||
| Backtracking (e.g., N-Queens) | |||
| Dynamic Programming (Intro, Memoization) | |||
| Path Compression, Union by Rank (Union Find) | |||
| Cycle Detection (Undirected Graph) | |||
| (Balanced BST based operations) (For Ordered Set) | |||
| Range Queries (Basic) | |||
| Insert, Search, Prefix Matching (Trie) | |||
| Word Break Problem (Trie approach) | |||
| Next Greater/Smaller Element (Monotonic Stack) | |||
| Largest Rectangle in Histogram | |||
| Sliding Window Maximum/Minimum (Monotonic Queue) | |||
| Rotations, Balancing (AVL/Red-Black Tree) | |||
| Counting Sort | |||
| Radix Sort | |||
| Bucket Sort | |||
| Range Queries, Updates (Segment Tree) | |||
| Lazy Propagation | |||
| Range Queries, Updates (BIT) | |||
| 2D BIT | |||
| Suffix Array Construction (Intro) | |||
| LCP Array | |||
| Search, Insert, Delete (Skip List) | |||
| Add, Check Membership (Bloom Filter) | |||
| (Database Indexing Operations) (B-Tree) | |||
| Get, Put Operations (LRU Cache) | |||
| LRU Cache (Core DS Logic) | |||
| Simulation | |||
| Enumeration | |||
| Topological Sort | |||
| Rolling Hash (Technique) | |||
| Shortest Path (Dijkstra's) | |||
| Minimum Spanning Tree (Prim's, Kruskal's) | |||
| Bellman-Ford Algorithm | |||
| Strongly Connected Components (SCC) | |||
| Biconnected Components | |||
| KMP Algorithm | |||
| Z-Algorithm | |||
| Aho-Corasick Algorithm | |||
| Eulerian Circuit/Path | |||
| Network Flow (Ford-Fulkerson) | |||
| Maximum Bipartite Matching | |||
| Johnson's Algorithm | |||
| Convex Hull Algorithm | |||
| Fast Fourier Transform (FFT) | |||
| Linear Programming | |||
| Max Flow Min Cut variants |
# Newly added for completeness and coverage of foundational topics.