GATE Computer Science and Information Technology (CS) Syllabus Topic Map & Practice

GATE CS tests engineering mathematics, digital logic, computer organisation, programming and data structures, algorithms, theory of computation, compiler design, operating systems, databases, and computer networks, plus a general aptitude section common to all GATE papers.

11 subjects · 66 topics · 480 subtopics

Official scope and learning resources

This is our practice taxonomy, not a verbatim official syllabus or a claim that every subtopic has published questions. Check the current official document before planning examination coverage.

Solved GATE CS previous year questions

1,495 questions with official answers and step-by-step solutions.

All GATE CS PYQs 2026 2025 2024 2023

General Aptitude

Revise General Aptitude: concept notes, worked examples and PYQs

Verbal Aptitude

English Grammar (Tenses, Articles, Prepositions, Conjunctions)
Verb-Noun Agreement & Parts of Speech
Vocabulary (Words, Idioms, Phrases in Context)
Reading Comprehension
Narrative Sequencing

Quantitative Aptitude

Data Interpretation (Bar, Pie, Graphs, Tables)
Ratios, Percentages, Powers, Exponents & Logarithms
Permutations & Combinations
Series
Mensuration & Geometry
Elementary Statistics & Probability
Simple & Compound Interest
Alligation & Mixture
Partnership
Time & Work

Analytical Aptitude

Deduction & Induction
Analogy
Numerical Relations & Reasoning

Spatial Aptitude

Transformation of Shapes (Translation, Rotation, Scaling, Mirroring)
Paper Folding, Cutting & Patterns
2D & 3D Patterns

Engineering Mathematics

Revise Engineering Mathematics: concept notes, worked examples and PYQs

Mathematical Logic

Propositional Logic
Truth Tables
Predicate Logic & Quantifiers
Logical Equivalence
Normal Forms (CNF, DNF)

Sets & Combinatorics

Sets, Relations & Functions
Partial Orders & Lattices
Groups, Rings & Fields
Permutations & Combinations
Pigeonhole Principle
Inclusion-Exclusion Principle
Generating Functions
Recurrence Relations

Graph Theory (Math)

Graph Terminology (Degree, Paths, Cycles)
Trees & Spanning Trees
Connectivity
Planarity
Graph Coloring
Matching
Euler & Hamiltonian Paths

Linear Algebra

Matrices & Determinants
Rank of a Matrix
System of Linear Equations
Eigenvalues & Eigenvectors
Cayley-Hamilton Theorem
Vector Spaces & Linear Maps
LU Decomposition

Calculus

Limits & Continuity
Differentiation
Mean Value Theorems
Maxima & Minima
Integration
Sequences & Series
Partial Derivatives

Probability & Statistics

Sample Space & Events
Conditional Probability
Bayes' Theorem
Random Variables
Discrete Distributions
Continuous Distributions
Expectation & Variance
Joint Distributions
Markov Chains

Digital Logic

Revise Digital Logic: concept notes, worked examples and PYQs

Boolean Algebra & Logic Gates

Boolean Laws & Theorems
De Morgan's Theorems
SOP & POS Forms
Minterms & Maxterms
K-Map Minimization
Quine-McCluskey Method
Universal Gates (NAND, NOR)

Combinational Circuits

Adders & Subtractors
Carry Lookahead Adder
Multiplexers & Demultiplexers
Encoders & Decoders
Comparators
Priority Encoders
Combinational Hazards

Sequential Circuits

Latches (SR, D)
Flip-Flops (JK, T, D)
Flip-Flop Conversions
Registers & Shift Registers
Counters (Sync, Async)
Moore & Mealy Machines
State Minimization
FSM Design

Number Systems & Arithmetic

Number Base Conversions
BCD, Gray & Excess-3 Codes
Signed Number Representations
Binary Arithmetic & Overflow
IEEE 754 Floating Point
Floating Point Arithmetic

Computer Organization & Architecture

Revise Computer Organization & Architecture: concept notes, worked examples and PYQs

Instructions & Addressing Modes

Instruction Formats
Instruction Types
Addressing Modes
RISC vs CISC
Subroutine Call & Return

ALU & Datapath

ALU Design
Booth's Multiplication
Restoring Division
Non-Restoring Division
Datapath & Register File
Hardwired vs Microprogrammed Control
Microprogramming

Instruction Pipelining

Pipeline Stages & Throughput
Speedup & Efficiency
Data Hazards (RAW, WAR, WAW)
Data Forwarding
Pipeline Stalls
Control Hazards
Branch Prediction
Structural Hazards
Instruction-Level Parallelism

Memory Hierarchy & Cache

Memory Technologies (SRAM, DRAM, ROM)
Direct-Mapped Cache
Set-Associative Cache
Fully Associative Cache
Cache Replacement Policies
Write-Through vs Write-Back
Cache Miss Types
Cache Numericals
Memory Interleaving

I/O Organization

I/O Interfaces & Buses
Programmed I/O (Polling)
Interrupt-Driven I/O
DMA (Operation & Types)
Disk Structure & Access Time
Disk Scheduling Algorithms

Programming & Data Structures

Revise Programming & Data Structures: concept notes, worked examples and PYQs

C Programming

Data Types & Operators
Control Flow
Functions & Recursion
Pointers & Pointer Arithmetic
Function Pointers
Arrays & Strings in C
Structures & Unions
Dynamic Memory Allocation
Storage Classes
Preprocessor & Macros

Arrays & Strings

Array Operations (1D, 2D)
Matrix Operations
String Pattern Matching (Naive)
Sparse Matrix Representation

Linked Lists

Singly Linked Lists
Doubly Linked Lists
Circular Linked Lists
List Reversal
Cycle Detection (Floyd's)
Skip Lists

Stacks & Queues

Stack Operations
Expression Evaluation
Balanced Parentheses
Next Greater Element
Queue & Circular Queue
Deque
Priority Queue

Trees

Binary Tree Properties
Tree Traversals
Binary Search Trees
BST Successor & Predecessor
AVL Trees
Red-Black Trees
B & B+ Trees
Segment & Fenwick Trees
Trie
Expression Trees

Heaps

Min-Heap & Max-Heap
Heapify & Build-Heap
Heap Insert & Extract
K-way Merge
Median with Two Heaps

Graphs (Data Structure)

Adjacency Matrix & List
BFS Traversal
DFS Traversal
Connected Components
Strongly Connected Components
Bipartite Detection

Hashing

Hash Functions
Chaining
Open Addressing
Load Factor & Rehashing
Hashing Performance

Algorithms

Revise Algorithms: concept notes, worked examples and PYQs

Asymptotic Analysis

Asymptotic Notations
Best, Worst, Average Case
Substitution Method
Recursion Tree Method
Master Theorem
Amortized Analysis
Space Complexity

Sorting

Comparison Sort Lower Bound
Bubble, Insertion, Selection Sort
Merge Sort
Quick Sort
Heap Sort
Counting, Radix, Bucket Sort
Sorting Stability
External Sorting

Searching

Linear Search
Binary Search & Variants
Interpolation Search
Selection (Order Statistics)

Greedy Algorithms

Activity Selection
Huffman Coding
Fractional Knapsack
Job Scheduling
Kruskal's MST
Prim's MST
Exchange Argument

Dynamic Programming

Optimal Substructure
Memoization vs Tabulation
Longest Common Subsequence
Longest Increasing Subsequence
0/1 Knapsack
Matrix Chain Multiplication
Edit Distance
Coin Change & Subset Sum
Optimal BST
Floyd-Warshall
Bellman-Ford
DP on Trees & Intervals

Divide & Conquer

D&C Paradigm
Merge Sort (D&C)
Quick Sort (D&C)
Binary Search (D&C)
Strassen's Multiplication
Closest Pair of Points
Karatsuba Multiplication

Graph Algorithms

BFS Shortest Path
DFS Edge Classification
Topological Sort
Cycle Detection
Dijkstra's Algorithm
Bellman-Ford Algorithm
Floyd-Warshall
Max Flow (Ford-Fulkerson)
Bipartite Matching
Articulation Points & Bridges
SCC (Kosaraju, Tarjan)

String Algorithms

KMP Algorithm
Rabin-Karp Algorithm
String Hashing
Suffix Arrays & Trees

Complexity Theory

P, NP, NP-Complete
Polynomial Reductions
NP-Complete Problems
Approximation Algorithms

Theory of Computation

Revise Theory of Computation: concept notes, worked examples and PYQs

Finite Automata & Regular Languages

DFA
NFA
NFA to DFA (Subset Construction)
Regular Expressions
RE to NFA (Thompson's)
DFA to RE
DFA Minimization
Pumping Lemma (Regular)
Closure Properties (Regular)
Decision Problems (Regular)

Context-Free Languages

Context-Free Grammars
Parse Trees & Derivations
Ambiguity
Chomsky Normal Form
Greibach Normal Form
Pushdown Automata (PDA)
DPDA vs NPDA
CFG-PDA Conversion
Pumping Lemma (CFL)
Closure Properties (CFL)
CYK Algorithm
Decision Problems (CFL)

Turing Machines & Computability

Turing Machines
TM Variants
Church-Turing Thesis
Recursive & RE Languages
Halting Problem
Rice's Theorem
Post Correspondence Problem
Undecidability Reductions
Chomsky Hierarchy

Compiler Design

Revise Compiler Design: concept notes, worked examples and PYQs

Lexical Analysis

Tokens & Lexemes
Regular Expressions for Tokens
Lexer Construction (DFA/NFA)
LEX Tool
Input Buffering

Syntax Analysis

CFGs for Parsing
Parse Trees
Left Factoring
Left Recursion Elimination
First & Follow Sets
Recursive Descent Parsing
LL(1) Parsing
LR(0) & SLR(1)
CLR(1) & LALR(1)
Parsing Conflicts
YACC Tool

Semantic Analysis

Attribute Grammars
S- & L-Attributed Grammars
Syntax-Directed Translation
Type Checking
Symbol Tables
Scoping (Static, Dynamic)

Intermediate Code Generation

Three-Address Code
DAG for Expressions
Backpatching
Translation of Expressions
Translation of Arrays

Code Optimization

Basic Blocks & Flow Graphs
Common Subexpression Elimination
Constant Folding & Propagation
Dead Code Elimination
Loop Optimizations
Liveness Analysis
Reaching Definitions
Register Allocation

Runtime Environments

Activation Records
Stack Allocation
Heap & Garbage Collection
Parameter Passing

Operating System

Revise Operating System: concept notes, worked examples and PYQs

OS Structure & System Calls

OS Functions & Structure
System Calls
User vs Kernel Mode
Interrupts & Traps

Processes & Threads

Process States & PCB
Process Creation (fork, exec)
User vs Kernel Threads
Multithreading Models
POSIX Threads
Context Switching

Process Scheduling

Scheduling Criteria
FCFS & SJF
SRTF (Preemptive SJF)
Priority Scheduling
Round Robin
Multilevel Feedback Queue
Scheduling Numericals

Process Synchronization

Race Conditions & Critical Section
Peterson's Algorithm
Test-and-Set & CAS
Mutex & Spinlocks
Semaphores
Producer-Consumer
Readers-Writers
Dining Philosophers
Monitors

Deadlocks

Coffman's Conditions
Resource Allocation Graph
Deadlock Prevention
Banker's Algorithm
Deadlock Detection
Deadlock Recovery
Deadlock Numericals

Memory Management

Contiguous Allocation
Fragmentation
Paging & Address Translation
Multilevel & Inverted Page Tables
Segmentation
Segmentation with Paging
Demand Paging
Page Replacement Algorithms
Thrashing & Working Set
TLB & EAT
Memory-Mapped Files

File Systems

File Concepts & Operations
Directory Structures
File Allocation Methods
Inode & Unix FS
Free Space Management
File System Mounting
RAID Levels

Inter-Process Communication

Shared Memory
Message Passing
Pipes & FIFOs
Sockets
Signals

Databases

Revise Databases: concept notes, worked examples and PYQs

ER Model

Entities & Attributes
Keys
Relationships
Cardinality & Participation
Weak Entities
Enhanced ER (Generalization)
ER to Relational Mapping

Relational Model

Relations & Domains
Keys (Super, Candidate, Foreign)
Selection & Projection
Set Operations
Joins
Division
Tuple Relational Calculus
Domain Relational Calculus

SQL

DDL Commands
DML Commands
Grouping & Ordering
SQL Joins
Subqueries
Aggregate Functions
Views
Triggers & Procedures
NULL & Three-Valued Logic
Query Optimization

Normalization

Functional Dependencies
Armstrong's Axioms
Attribute Closure
Canonical Cover
Candidate Keys from FDs
1NF, 2NF, 3NF
BCNF
4NF & MVDs
Lossless Decomposition
Dependency Preservation

Indexing & File Organization

Primary & Secondary Indexes
Dense vs Sparse Indexes
Multi-Level Indexing
B-Tree Operations
B+ Tree Operations
B+ Tree Numericals
Static & Dynamic Hashing
ISAM

Transactions & Concurrency

ACID Properties
Transaction States
Serial vs Non-Serial Schedules
Conflict Serializability
View Serializability
Recoverability
Lock-Based Protocols
Two-Phase Locking
Timestamp Protocols
MVCC
Log-Based Recovery

Computer Networks

Revise Computer Networks: concept notes, worked examples and PYQs

Network Fundamentals

Network Types (LAN, WAN, MAN)
OSI Model
TCP/IP Model
Switching Techniques
Transmission Media
Shannon & Nyquist Theorems

Data Link Layer

Framing
Error Detection (Parity, CRC)
Error Correction (Hamming)
Stop-and-Wait
Go-Back-N
Selective Repeat
Efficiency Numericals

Medium Access & LANs

ALOHA (Pure, Slotted)
CSMA/CD
CSMA/CA
Token Ring & Polling
Ethernet & MAC
Switches & STP
VLANs

Transport Layer

Multiplexing & Reliability
UDP
TCP Handshake
TCP Teardown
TCP Segment Format
TCP Reliable Transfer
TCP Flow Control
TCP Congestion Control
Fast Retransmit & Recovery
TCP vs UDP
Socket Programming

Application Layer

DNS
HTTP & HTTPS
FTP
SMTP, POP3, IMAP
Symmetric & Asymmetric Encryption
Digital Signatures & Certificates
Firewalls & Proxies

Track your progress across this entire syllabus

Topic-wise practice with skill scores for every subtopic above.

Start free