Programming and Data Structures PYQs for GATE CS

GATE CS Programming and Data Structures: 7 chapters, 66 previous year questions (100% of Programming and Data Structures), 563 practice questions and one solved question from each chapter.

About Programming and Data Structures Previous Year Questions (PYQs)

66 previous year questions from Programming and Data Structures in GATE CS, grouped by chapter with the exam year, answer key and step-by-step solution for each.

Programming and Data Structures Weightage in GATE CS

Programming and Data Structures accounts for 66 of 66 Programming and Data Structures previous year questions in our bank (100%), about 6.6 per paper across 10 papers.

Programming and Data Structures Chapter Matrix

Chapter	Topics	PYQs	Share of unit PYQs	Practice questions
C Programming, Control Flow and Array Algorithms	Loop Tracing and Iterative Computation, Function Calls, Evaluation Order and Static State, Bitwise and Character Expressions, Array Processing and Iterative Algorithms, Variable Scope, Shadowing and Compilation	13	20%	193
Pointers, Arrays, Strings and Memory Management	Pointer Assignment, Dereferencing and Arithmetic, Strings and Character Pointers, Multidimensional Arrays and Memory Layout, Runtime Memory and Dynamic Allocation	10	15%	153
Recursion and Recursive Program Analysis	Recursive Array and String Traversal, Recursive Arithmetic Algorithms, Nested Recursion and Return-Value Analysis	6	9%	0
Stacks, Queues and Linked Lists	Stack Operations and Augmented Stacks, Queue Operations, Reversal and Stack-Queue Interaction, Linked List Manipulation, Recursion and Complexity	11	17%	60
Binary Trees, Binary Search Trees and Traversals	Binary Tree Structure, Height and Node Counts, Binary Search Tree Construction and Ordering Properties, Tree Traversals and Recursive Tree Processing, Complete Binary Search Trees in Array Representation	13	20%	127
Heaps, Priority Queues and Data Structure Operations	Heap Structure, Height and Leaf Positions, Heap Construction and Array Validation, Priority Queue Operations and Heap Extrema, Meld Operations and Data Structure Complexity	8	12%	30
Hashing and Collision Resolution	Open Addressing and Probe Sequences, Uniform Hashing and Expected Load, Dynamic Hashing and Collision Buckets, Separate Chaining and Chain Length	5	8%	0

One Solved Question from Each Programming and Data Structures Chapter

Question 1 · C Programming, Control Flow and Array Algorithms · 2026_Set2 MCQ

Consider the following three ANSI-C programs, P1, P2, and P3.

P1	P2	P3
#include <stdio.h> int a=5; int main(){ int a=7; return(0); }	#include <stdio.h> int main(){ int a=5; int a=7; return(0); }	#include <stdio.h> int main(){ int a=5; float a=7; return(0); }

Which one of the following statements is true?

A.
Only P1 will compile without any error
B.
Only P2 will compile without any error
C.
Only P3 will compile without any error
D.
All three programs P1, P2, and P3 will compile without any error

Correct Answer:

Step-by-Step Solution

Insight: C allows variable shadowing across different scopes but forbids redeclaration within the same scope, regardless of type.

Exam route: Check the scope of each variable declaration. Global vs local is shadowing. Two locals in the same block is redeclaration.

Learning route:

P1: int a=5; is at file scope. int a=7; is inside main (block scope). The local a shadows the global a. This is perfectly valid C and compiles without error.
P2: int a=5; and int a=7; are both declared inside the exact same block scope (main). This is a redeclaration error. The compiler will reject it.
P3: int a=5; and float a=7; are both in the same block scope. Even though the types differ, C does not allow overloading or redeclaration with different types in the same scope. This is a compilation error.
Therefore, only P1 compiles successfully.

Trap: Believing that shadowing causes a compilation error or that different types in the same scope are allowed. Shadowing is strictly cross-scope; redeclaration is strictly intra-scope.

Verification: Compile P1 mentally: global a exists, local a hides it. No conflict. P2: compiler sees two as in main's symbol table -> error. P3: same symbol table, conflicting types -> error.

Question 2 · Pointers, Arrays, Strings and Memory Management · 2026_Set2 MCQ

In C runtime environment, which one of the following is stored in heap?

A.
A static variable declared inside a function
B.
An array of integers declared inside a function
C.
A dynamically allocated array of integers created using malloc() function call
D.
Return address of a function

Correct Answer:

Step-by-Step Solution

Insight: This is a memory layout classification question, recognizable by asking where specific C constructs reside in the runtime environment.

Exam route: Eliminate options based on standard C memory segments. Static variables go to Data/BSS. Local arrays and return addresses go to Stack. Only malloc targets the Heap.

Learning route:

Static variable inside a function: Stored in the Data segment (or BSS if uninitialized), not the Heap.
Array of integers declared inside a function: This is a local variable, allocated on the Stack.
Dynamically allocated array using malloc(): Explicitly requests memory from the Heap at runtime.
Return address of a function: Pushed onto the Stack as part of the function call frame.

Therefore, only the dynamically allocated array resides in the Heap.

Question 3 · Recursion and Recursive Program Analysis · 2021_Set2 NAT

Consider the following ANSI C program.

#include <stdio.h>

int foo(int x, int y, int q)
{
    if ((x <= 0) && (y <= 0))
        return q;
    if (x <= 0)
        return foo(x, y-q, q);
    if (y <= 0)
        return foo(x-q, y, q);
    return foo(x, y-q, q) + foo(x-q, y, q);
}

int main()
{
    int r = foo(15,15,10);
    printf("%d", r);
    return 0;
}

The output of the program upon execution is __________.

Correct Answer:

60.00

Step-by-Step Solution

Insight: The function acts as a path counter on a 2D grid, stepping by $q$ in either the $x$ or $y$ direction, with base cases returning $q$ when both coordinates drop to $\leq 0$ .

Exam route: Trace the recursive tree for foo(15, 15, 10). Notice the symmetric reduction and how boundary conditions collapse the tree into simple additions of the constant $q = 10$ .

Learning route:

This is a multi-variable path counting question, recognisable by two coordinate arguments reducing independently in separate recursive branches.
The function foo(x, y, q) has constant q = 10. Let's trace f(x, y) = foo(x, y, 10).
Base cases:

If $x \leq 0$ and $y \leq 0$ , return $10$ .
If $x \leq 0$ , return $f (x, y - 10)$ .
If $y \leq 0$ , return $f (x - 10, y)$ .

Recursive step: If $x > 0$ and $y > 0$ , return $f (x, y - 10) + f (x - 10, y)$ .
Calculate $f (15, 15)$ :

$f (15, 15) = f (15, 5) + f (5, 15)$

Calculate $f (15, 5)$ :

$f (15, 5) = f (15, - 5) + f (5, 5)$
$f (15, - 5)$ : Since $y \leq 0$ , it returns $f (5, - 5) \to f (- 5, - 5) = 10$ .
$f (5, 5) = f (5, - 5) + f (- 5, 5) = 10 + 10 = 20$ .
So, $f (15, 5) = 10 + 20 = 30$ .

Calculate $f (5, 15)$ :

By symmetry, $f (5, 15) = f (5, 5) + f (- 5, 15) = 20 + 10 = 30$ .

Final result: $f (15, 15) = 30 + 30 = 60$ .

Question 4 · Stacks, Queues and Linked Lists · 2026_Set2 MSQ

Consider a stack

S

and a queue

Q

. Both of them are initially empty and have the capacity to store ten elements each. The elements 1, 2, 3, 4, and 5 arrive one by one, in that order. When an element arrives, it is assigned either to

S

(pushed on

S

) or to

Q

(enqueued to

Q

). Once all the five elements are stored, the output is generated in two steps. First, stack S is emptied by popping all elements. Then queue

Q

is emptied by dequeueing all elements. The output obtained by following this process is 4 3 1 2 5 .
Given the output, the objective is to predict whether an element was assigned to

S

Q

.

Which of the following options is/are possible valid assignment(s) of the elements?

Note: In the options, the notation

x_{S}

denotes that element

x

was assigned to

S

and

y_{Q}

denotes that element

y

was assigned to

Q

A.
$1_{S}, 2_{Q}, 3_{S}, 4_{S}, 5_{Q}$
B.
$1_{Q}, 2_{Q}, 3_{S}, 4_{S}, 5_{Q}$
C.
$1_{Q}, 2_{Q}, 3_{Q}, 4_{S}, 5_{S}$
D.
$1_{S}, 2_{S}, 3_{S}, 4_{Q}, 5_{Q}$

Correct Answer:

["A","B"]

Step-by-Step Solution

Insight: This is a stack-queue stream splitting question, recognizable because it asks to deduce the routing of elements into a stack and a queue given the final concatenated output.

Exam route: Partition the output into a stack segment (reversed arrival) and a queue segment (original arrival), then interleave them to match 1, 2, 3, 4, 5.

Learning route:

Step 1: The final output is 4, 3, 1, 2, 5. This is formed by emptying the stack (LIFO) followed by emptying the queue (FIFO).

Step 2: We must partition the output into a stack segment and a queue segment.

Partition A: Stack outputs 4, 3, 1. Queue outputs 2, 5.

For the stack to output 4, 3, 1, the elements must have been pushed in the order 1, 3, 4.

For the queue to output 2, 5, the elements must have been enqueued in the order 2, 5.

Interleaving 1, 3, 4 and 2, 5 to match the arrival order 1, 2, 3, 4, 5 gives: 1->S, 2->Q, 3->S, 4->S, 5->Q. This matches option A.

Partition B: Stack outputs 4, 3. Queue outputs 1, 2, 5.

For the stack to output 4, 3, the elements must have been pushed in the order 3, 4.

For the queue to output 1, 2, 5, the elements must have been enqueued in the order 1, 2, 5.

Interleaving 3, 4 and 1, 2, 5 to match 1, 2, 3, 4, 5 gives: 1->Q, 2->Q, 3->S, 4->S, 5->Q. This matches option B.

Step 3: Verify other partitions. If stack outputs 4, queue outputs 3, 1, 2, 5. The queue arrival order would be 3, 1, 2, 5, which violates the increasing arrival order. Thus, only A and B are valid.

Question 5 · Binary Trees, Binary Search Trees and Traversals · 2026_Set2 MCQ

The set T represents various traversals over binary tree. The set S represents the order of visiting nodes during a traversal.

T	S
I: Inorder	L: left subtree, node, right subtree
II: Preorder	M: node, left subtree, right subtree
III: Postorder	N: left subtree, right subtree, node

Which one of the following is the correct match from T to S ?

A.
I – L, II – M, III – N
B.
I – M, II – L, III – N
C.
I – N, II – M, III – L
D.
I – L, II – N, III – M

Correct Answer:

Step-by-Step Solution

Insight: The names of the traversals (pre, in, post) directly indicate the position of the current node relative to its subtrees.

Exam route: Preorder = Node first (pre). Inorder = Node in the middle (in). Postorder = Node last (post). Match these to the given descriptions: I (Inorder) is L (left, node, right). II (Preorder) is M (node, left, right). III (Postorder) is N (left, right, node). This matches option A.

Learning route:

Depth-first traversals are defined by when the current node is processed relative to its left and right subtrees.
Preorder: The prefix "pre" means the node is visited before its subtrees. Order: Node, Left, Right (M).
Inorder: The prefix "in" means the node is visited in between its left and right subtrees. Order: Left, Node, Right (L).
Postorder: The prefix "post" means the node is visited after both subtrees. Order: Left, Right, Node (N).
Matching these definitions to the given set S yields I-L, II-M, III-N.

Verification: Consider a tree with root A, left B, right C. Preorder visits A, then B, then C (Node, Left, Right). Inorder visits B, then A, then C (Left, Node, Right). Postorder visits B, then C, then A (Left, Right, Node). This perfectly matches M, L, N respectively.

Question 6 · Heaps, Priority Queues and Data Structure Operations · 2025_Set1 NAT

The height of any rooted tree is defined as the maximum number of edges in the path from the root node to any leaf node.

Suppose a Min-Heap

T

stores 32 keys. The height of

T

is _____________. (Answer in integer)

Correct Answer:

5.00

Step-by-Step Solution

Insight: This is a direct application of the heap height formula. The height of a complete binary tree with $n$ nodes is simply $⌊ lo g_{2} n ⌋$ .

Exam route: The problem states the min-heap stores 32 keys. Using the height formula $h = ⌊ lo g_{2} n ⌋$ , we substitute $n = 32$ . Since $32 = 2^{5}$ , $lo g_{2} 32 = 5$ . The floor of 5 is 5. The height is 5.

Learning route:

Understand the definition: The height of a rooted tree is the maximum number of edges on any path from the root to a leaf.
Recall the structure of a heap: A heap is a complete binary tree. This means all levels except possibly the last are completely full, and the last level is filled from left to right.
Apply the formula: For a complete binary tree with $n$ nodes, the height $h$ is given by $h = ⌊ lo g_{2} n ⌋$ .
Calculate: Here, $n = 32$ . We know that $2^{5} = 32$ , so $lo g_{2} 32 = 5$ .
Conclusion: The height of the min-heap is 5.

Question 7 · Hashing and Collision Resolution · 2026_Set2 NAT

The keys $5, 28, 19, 15, 26, 33, 12, 17, 10$ are inserted into a hash table using the hash function $h (k) = k mod 9$ . The collisions are resolved by chaining. After all the keys are inserted, the length of the longest chain is __________. <i>(answer in integer)</i>

Correct Answer:

3.00

Step-by-Step Solution

Insight: Separate chaining appends colliding keys to a linked list at the hashed index; the longest chain is simply the maximum bucket size.

Exam route: Compute $k mod 9$ for all 9 keys, tally the frequencies of each remainder, and pick the maximum frequency.

Learning route:

The hash function is $h (k) = k mod 9$ .

Compute the bucket for each key:

$5 mod 9 = 5$
$28 mod 9 = 1$
$19 mod 9 = 1$
$15 mod 9 = 6$
$26 mod 9 = 8$
$33 mod 9 = 6$
$12 mod 9 = 3$
$17 mod 9 = 8$
$10 mod 9 = 1$

Tallying the remainders:

Index 0: 0 keys
Index 1: 28, 19, 10 (3 keys)
Index 2: 0 keys
Index 3: 12 (1 key)
Index 4: 0 keys
Index 5: 5 (1 key)
Index 6: 15, 33 (2 keys)
Index 7: 0 keys
Index 8: 26, 17 (2 keys)

The maximum number of keys in any bucket is 3 (at index 1).

Thus, the length of the longest chain is 3.

Tempting wrong path: A student might count the total number of collisions instead of the maximum chain length. There are 4 collisions (28 collides with 19, 10 collides with them, 33 collides with 15, 17 collides with 26), leading to an answer of 4. This breaks down because "longest chain" refers to the maximum bucket size, not the sum of collisions.

Generalization: In separate chaining, the chain length at any index is exactly the frequency of that hash value.

Verification: Re-checking $28 = 3 \times 9 + 1$ , $19 = 2 \times 9 + 1$ , $10 = 1 \times 9 + 1$ . All correctly map to 1. No other bucket has 3 or more keys.

A question from this chapter

Login to view the complete previous-year questions and solutions

Personalised first. High quality throughout.

Built around you, not around a syllabus PDF

Revision that hits your weak spots

Questions calibrated to the real exam

Notes written for recall, not for volume

One place for everything

Honest progress

Unlock the whole course

Programming and Data Structures PYQs for GATE CS

About Programming and Data Structures Previous Year Questions (PYQs)

Programming and Data Structures Weightage in GATE CS

Programming and Data Structures Chapter Matrix

More from Programming and Data Structures

One Solved Question from Each Programming and Data Structures Chapter

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution