Roadmaps › CS Fundamentals
GATE CSE Roadmap
The complete GATE Computer Science syllabus in a sensible order — with weightage tips, previous-year practice and a revision plan.
Level: Intermediate → Advanced · Duration: 8–12 months
Step 1: Know the exam
Plan with the pattern and weightage in mind.
GATE CSE decides M.Tech admissions at IITs/NITs and PSU jobs. Smart preparation starts with the pattern, weightage and a realistic plan.
- Paper pattern and marking
- Subject-wise weightage
- A month-by-month plan
Resources: GATE Overflow — syllabus & previous papers
Exam pattern
65 questions, 100 marks, 3 hours; MCQ, MSQ and NAT.
65 questions for 100 marks in 3 hours: 1- and 2-mark questions, MCQ (negative marking), MSQ and NAT (no negative marking).
- MCQ: −1/3 or −2/3 for wrong answers
- MSQ and NAT: no negative marks
- Virtual calculator practice
Syllabus & weightage
Which subjects give the most marks.
General aptitude (15) and engineering maths (~13) are fixed; algorithms, OS, DBMS, CN, TOC and COA carry the most technical marks.
- Official syllabus by subject
- High-weightage subjects first
- Topics asked every year
Study plan
Subject order, daily targets, revision cycles.
Cover every subject once, then revise and practise repeatedly.
- Subject order (start with DS & algorithms, discrete maths)
- Daily study targets
- Revision every 2–3 weeks
- Last 3 months: tests and PYQs
Step 2: Engineering mathematics & aptitude
About 28 marks — high scoring with practice.
About 28 marks come from aptitude and maths — among the easiest marks to secure with regular practice.
- General aptitude
- Discrete mathematics
- Linear algebra and calculus
- Probability
Resources: Notes: Quant Formula Sheet · Aptitude practice · ▶ Discrete Mathematics
General aptitude
15 marks of verbal and numerical ability.
Verbal and numerical ability — 15 marks, same for every GATE paper.
- Grammar and vocabulary
- Percentages, ratios, time and work
- Data interpretation
- Spatial and logical reasoning
Resources: Notes: Logical Reasoning Tricks
Discrete mathematics
Logic, sets, relations, graphs, combinatorics.
The language of computer science and a frequent source of tricky questions.
- Propositional and first-order logic
- Sets, relations, functions, partial orders, lattices
- Groups
- Graph theory and combinatorics (recurrences, generating functions)
Linear algebra & calculus
Matrices, eigenvalues, limits, integrals.
Short, formula-based questions.
- Matrices, determinants, rank
- Systems of linear equations
- Eigenvalues and eigenvectors, LU decomposition
- Limits, continuity, maxima/minima, integration
Probability & statistics
Distributions, conditional probability.
Common NAT questions.
- Conditional probability and Bayes' theorem
- Random variables, mean, variance
- Uniform, normal, exponential, Poisson, binomial distributions
Resources: Notes: Probability Shortcuts
Step 3: Programming & data structures
C programming and core structures.
C programming and data structures are high-weightage and form the base for algorithms.
- C programming
- Linear data structures
- Trees and heaps
- Hashing
Resources: C documentation · Notes: Pointers in C · ▶ C Language Tutorials
C programming
Pointers, recursion, scope, parameter passing.
Output-prediction questions test pointers, recursion and scope.
- Pointers and arrays
- Recursion tracing
- Static and global variables, scope
- Parameter passing
Resources: Notes: Dynamic Memory in C
Arrays, stacks & queues
Implementations and applications.
Implementation details and applications are both asked.
- Array address calculation (row/column major)
- Stack applications: expression evaluation, infix → postfix
- Queue and circular queue
Resources: Notes: Stack and Queue
Linked lists & trees
BST, AVL, heaps.
Tree questions are frequent — traversals, counts and properties.
- Linked list operations
- Binary tree traversals and counting nodes
- BST and AVL rotations
- Binary heaps: insert, delete, build
Resources: Notes: Linked List · Notes: Binary Trees and BST · Notes: Heaps
Hashing
Collision resolution.
Collision handling and probe counts.
- Hash functions
- Chaining
- Linear and quadratic probing
Resources: Notes: Hashing
Step 4: Algorithms
Analysis and design techniques.
Algorithms carry heavy weightage — analysis, design paradigms and graph algorithms.
- Asymptotic analysis
- Sorting and searching
- Greedy and dynamic programming
- Graph algorithms
Resources: Big-O Complexity documentation · ▶ Algorithms
Asymptotic analysis & recurrences
Master theorem.
Comparing growth rates and solving recurrences appear every year.
- Big-O, Ω, Θ
- Master theorem
- Recursion tree method
Resources: Notes: Big-O
Sorting & searching
Comparisons, stability, lower bounds.
Know best, average and worst cases and the number of comparisons/swaps.
- Insertion, merge, quick, heap sort
- Stability and in-place properties
- Binary search
- Lower bound for comparison sorting
Resources: Notes: Sorting Algorithms
Greedy & dynamic programming
Huffman, knapsack, LCS, matrix chain.
Classic problems with standard recurrences.
- Huffman coding, fractional knapsack, activity selection
- 0/1 knapsack, LCS, matrix chain multiplication
- Counting DP table entries
Resources: Notes: Greedy · Notes: Dynamic Programming
Graph algorithms
BFS, DFS, shortest paths, MST.
Traversals, shortest paths and spanning trees.
- BFS/DFS and their trees
- Dijkstra and Bellman–Ford
- Prim and Kruskal
- Topological sort
Resources: Notes: Shortest Paths and MST
Step 5: Theory of computation & compilers
Automata, languages and compiler phases.
TOC is concept-heavy and scoring once you know the standard results; compiler design follows from it.
- Regular languages
- Context-free languages
- Turing machines and decidability
- Compiler phases and parsing
Resources: ▶ Theory of Computation · ▶ Compiler Design
Regular languages
DFA, NFA, regular expressions, pumping lemma.
Finite automata and regular expressions.
- DFA and NFA, conversion, minimisation
- Regular expressions
- Closure properties
- Pumping lemma
Resources: Regex documentation
Context-free languages
Grammars, PDA, closure properties.
Grammars and pushdown automata.
- CFGs and derivations, ambiguity
- PDA and DPDA
- Closure and decision properties
Turing machines
Decidability basics.
What computers can and cannot decide.
- Recursive vs recursively enumerable languages
- Undecidable problems
- Reductions
Compiler design
Lexing, parsing (LL, LR), SDT, code generation.
Parsing tables and syntax-directed translation are frequent questions.
- Lexical analysis
- FIRST/FOLLOW, LL(1), LR(0), SLR, LALR, CLR
- Syntax-directed translation
- Intermediate code, basic blocks, liveness
Step 6: Digital logic & computer organisation
Hardware fundamentals.
Hardware topics with numerical questions on caches and pipelines.
- Boolean logic and circuits
- Number systems
- CPU design
- Memory and I/O
Resources: ▶ Digital Logic · ▶ Computer Organization and Architecture
Digital logic
Boolean algebra, K-maps, combinational & sequential circuits.
Minimisation and circuit questions.
- Boolean algebra and K-maps
- Multiplexers, decoders, adders
- Flip-flops and counters
Number representation
Two's complement, IEEE 754.
Conversions and ranges.
- Signed numbers and two's complement
- Overflow
- IEEE 754 floating point
Computer organisation
Instruction formats, addressing modes, pipelining.
How instructions execute.
- Instruction formats and addressing modes
- ALU, data path and control unit
- Pipelining and hazards (speed-up calculations)
Memory hierarchy
Cache mapping, hit ratio, I/O.
Cache questions are almost guaranteed.
- Direct, associative and set-associative mapping
- Hit ratio and average access time
- Main memory and secondary storage
- I/O: interrupts and DMA
Step 7: Operating systems
Processes, scheduling, memory and files.
OS has high weightage with many numerical questions.
- Processes and scheduling
- Synchronisation and deadlocks
- Memory management
- File systems
Resources: ▶ Operating System · Interview questions: Operating Systems
Processes & CPU scheduling
Gantt charts, waiting time.
Draw Gantt charts quickly and accurately.
- Process states and context switches
- FCFS, SJF, SRTF, priority, round robin
- Waiting and turnaround time
Resources: Notes: CPU Scheduling Algorithms
Synchronisation & deadlocks
Semaphores, Banker's algorithm.
Semaphore code tracing and Banker's algorithm are classics.
- Critical section requirements
- Semaphores and mutexes
- Deadlock conditions, prevention, avoidance (Banker's)
- Classic problems
Resources: Notes: Process Synchronization · Notes: Deadlocks
Memory management
Paging, TLB, page replacement.
Paging calculations appear every year.
- Paging, page tables, multilevel paging
- TLB and effective access time
- Page replacement: FIFO, LRU, optimal
- Thrashing
Resources: Notes: Memory Management · Notes: Page Replacement
File systems & disks
Allocation, disk scheduling.
Allocation and disk scheduling numericals.
- Contiguous, linked and indexed allocation; inodes
- Disk scheduling: FCFS, SSTF, SCAN, C-SCAN, LOOK
- Disk access time
Resources: Notes: File Systems and Disk Scheduling
Step 8: Databases
ER model, normalisation, SQL and transactions.
DBMS questions are standard and very scoring.
- ER model and relational algebra
- Functional dependencies and normal forms
- SQL
- Transactions and indexing
Resources: ▶ DBMS Complete Playlist · Interview questions: DBMS
ER model & relational algebra
Converting ER to tables.
Design and query languages.
- ER diagrams and minimum number of tables
- Relational algebra operators
- Tuple relational calculus
Resources: Notes: ER Model
Normalisation
Functional dependencies, keys, 1NF–BCNF.
FDs, closures and normal forms.
- Attribute closure and candidate keys
- Minimal cover
- 1NF, 2NF, 3NF, BCNF
- Lossless join and dependency preservation
Resources: Notes: Keys and Normalization
SQL
Queries, joins, aggregates.
Predict the output of queries.
- Joins, nested and correlated subqueries
- GROUP BY and HAVING
- NULL handling
Resources: Notes: SQL Essentials and Joins
Transactions & concurrency
Serializability, 2PL, recoverability.
Schedule-analysis questions.
- ACID
- Conflict and view serializability
- Recoverable and cascadeless schedules
- 2PL and timestamp protocols
Resources: Notes: Concurrency Control
Indexing
B and B+ trees.
B/B+ tree order and height calculations.
- Primary, clustered and secondary indexes
- B and B+ tree order calculations
- Insertion and splitting
Resources: Notes: Indexing and B+ Trees
Step 9: Computer networks
Layers, addressing and protocols.
Networks mix concepts with numericals on subnets, windows and delays.
- Data link layer
- Network layer and addressing
- Transport layer
- Application layer
Resources: ▶ Computer Networks · Interview questions: Computer Networks
Layering & data link
Framing, error detection, sliding window, Ethernet.
Framing, errors and flow control.
- OSI and TCP/IP layers
- Error detection: CRC, checksum
- Stop-and-wait, Go-Back-N, Selective Repeat (efficiency)
- Ethernet and CSMA/CD
Resources: Notes: OSI and TCP/IP
IP addressing & routing
Subnetting, CIDR, routing algorithms.
Subnetting is asked every year.
- IPv4, CIDR and subnetting
- Fragmentation
- Distance vector and link state routing
- ARP, DHCP, ICMP, NAT
Resources: Notes: IP Addressing and Subnetting · Notes: Routing
Transport layer
TCP, UDP, congestion control.
TCP behaviour and calculations.
- TCP vs UDP
- Connection management
- Flow control and congestion control (slow start, AIMD)
Resources: Notes: TCP vs UDP
Application layer
DNS, HTTP, SMTP.
Protocols and their ports.
- DNS
- HTTP
- SMTP, POP3, IMAP, FTP
Resources: Notes: DNS · Notes: HTTP
Step 10: Practice & revision
Marks come from practice under exam conditions.
Previous-year questions and timed tests turn knowledge into marks.
- Subject-wise PYQs
- Full-length mock tests
- Compact revision notes
Previous year questions
Solve the last 10–15 years subject-wise.
GATE repeats ideas often. Solve PYQs right after finishing each subject.
- Last 10–15 years subject-wise
- Analyse every mistake
- Mark questions to revisit
Resources: GATE Overflow
Mock tests
Full-length tests every week in the last 3 months.
Build speed, accuracy and exam temperament.
- Weekly full-length tests in the final months
- Time management: attempt order
- Avoiding negative marks on guesses
Short notes & formula sheets
One page per subject for final revision.
One-page summaries make the final weeks efficient.
- Formulas and standard results per subject
- Common traps
- Quick revision schedule