Stacks, Queues and Deques Previous Year Questions (PYQs) for GATE DA: 3+ Solved Questions with Step-by-Step Solutions

Solve 3+ Stacks, Queues and Deques previous year questions for GATE DA with answers and detailed solutions. Free sample questions below.

Chapter Roadmap: Stacks, Queues, and Deques

Chapter Journey: Linear Data Structures

Stack Operations and Simulation

Master Push, Pop, and Top. Learn to trace complex pseudocode executions manually.

Weightage Hint: High frequency in simulation questions.

Queue and Deque Operations

Understand F I F O behavior, circular queues, and double-ended insertion and removal.

Weightage Hint: Essential for scheduling and buffering concepts.

ADT Properties: FIFO, LIFO, Lookup

Formalize the abstract definitions. Match properties to real-world applications.

Weightage Hint: Conceptual clarity for matching and theory questions.

The Stack Intuition: The Plate Pile

What is a Stack?

A Stack is a linear data structure that follows a particular order in which operations are performed. The order may be LIFO (Last In First Out) or FILO (First In Last Out).

Real-World Analogy

Imagine a stack of books on a table:

You place Book A down.
You place Book B on top of A.
You place Book C on top of B.

To access Book A, you must first remove Book C, then Book B. The last item added (C) is the first one removed.

Book C

Book B

Book A

Key Terminology

Top: The only end where insertion and deletion occur.
Push: The operation of adding an element to the top.
Pop: The operation of removing the element from the top.

Stacks, Queues and Deques: Solved Questions with Step-by-Step Explanations (3 Problems)

Question 1 · Programming, Data Structures and Algorithms NAT

Consider the following pseudocode.

Create empty stack S

Set x=0, flag=0, sum=0

Push x onto S

while (S is not empty){

    if (flag equals 0){

        Set x = x+1

        Push x onto S}

    if (x equals 8):

    Set flag=1

    if (flag equals 1){

    x = Pop(S)

    if (x is odd):

    Pop(S)

    Set sum = sum + x}

}

Output sum

The value of sum output by a program executing the above pseudocode is
(Answer in integer)

Correct Answer:

Step-by-Step Solution

Key idea: This is a stack simulation question, recognizable because it provides pseudocode with stack operations (Push, Pop) and conditional logic, asking for the final state of a variable.

Step 1: Initialize variables. $x = 0$ , $f l a g = 0$ , $s u m = 0$ . Stack $S$ is initialized with $0$ , so $S = [0]$ .

Step 2: Trace the loop while $S$ is not empty.

Iterations 1 to 7: $f l a g$ is $0$ . $x$ increments by $1$ each time and is pushed. $S$ becomes $[0, 1, 2, 3, 4, 5, 6, 7]$ . $x$ reaches $7$ .
Iteration 8: $f l a g = 0$ , so $x$ becomes $8$ and is pushed. $S = [0, 1, 2, 3, 4, 5, 6, 7, 8]$ . Now $x = 8$ , so $f l a g$ becomes $1$ . Since $f l a g = 1$ , we execute the pop block: $x = P o p (S) = 8$ . $8$ is even, so the inner pop is skipped. $s u m = 0 + 8 = 8$ .
Iteration 9: $f l a g = 1$ . $x = P o p (S) = 7$ . $7$ is odd, so we $P o p (S)$ again, removing $6$ . $S$ is now $[0, 1, 2, 3, 4, 5]$ . $s u m = 8 + 7 = 15$ .
Iteration 10: $f l a g = 1$ . $x = P o p (S) = 5$ . $5$ is odd, so we $P o p (S)$ again, removing $4$ . $S$ is now $[0, 1, 2, 3]$ . $s u m = 15 + 5 = 20$ .
Iteration 11: $f l a g = 1$ . $x = P o p (S) = 3$ . $3$ is odd, so we $P o p (S)$ again, removing $2$ . $S$ is now $[0, 1]$ . $s u m = 20 + 3 = 23$ .
Iteration 12: $f l a g = 1$ . $x = P o p (S) = 1$ . $1$ is odd, so we $P o p (S)$ again, removing $0$ . $S$ is now $[]$ . $s u m = 23 + 1 = 24$ .

Step 3: The stack is now empty, so the loop terminates. The final value of $s u m$ is $24$ .

Answer: 24

Question 2 · Programming, Data Structures and Algorithms MCQ

Match the items in Column 1 with the items in Column 2 in the following table:

Column 1	Column 2
(p) First In First Out	(i) Stacks
(q) Lookup Operation	(ii) Queues
(r) Last In First Out	(iii) Hash Tables

A.
(p) − (ii), (q) − (iii), (r) − (i)
B.
(p) − (ii), (q) − (i), (r) − (iii)
C.
(p) − (i), (q) − (ii), (r) − (iii)
D.
(p) − (i), (q) − (iii), (r) − (ii)

Correct Answer:

Step-by-Step Solution

Key idea: This is an ADT property matching question, recognizable because it asks to pair fundamental access patterns (FIFO, LIFO, Lookup) with their corresponding data structures.

Step 1: Analyze "First In First Out" (p). This is the defining property of a Queue, where the first element added is the first to be removed. So, (p) matches with (ii).

Step 2: Analyze "Last In First Out" (r). This is the defining property of a Stack, where the most recently added element is the first to be removed. So, (r) matches with (i).

Step 3: Analyze "Lookup Operation" (q). Hash Tables are specifically designed to provide fast, average-case $O (1)$ key-based lookup operations. So, (q) matches with (iii).

Step 4: Combine the matches: (p) - (ii), (q) - (iii), (r) - (i).

Answer: Option A

Question 3 · Programming, Data Structures and Algorithms NAT

The fundamental operations in a double-ended queue

D

are:
insertFirst(e) – Insert a new element e at the beginning of D.
insertLast(e) – Insert a new element e at the end of D.
removeFirst() – Remove and return the first element of D.
removeLast() – Remove and return the last element of D.
In an empty double-ended queue, the following operations are performed:
insertFirst(10)
insertLast(32)
a ←removeFirst()
insertLast(28)
insertLast(17)
a ←removeFirst()
a ← removeLast()
The value of a is ______.

Correct Answer:

Step-by-Step Solution

Key idea: This is a deque simulation question, recognizable because it provides a sequence of double-ended queue operations and asks for the final value of a variable.

Step 1: Start with an empty deque $D$ .

Step 2: insertFirst(10): $D = [10]$

Step 3: insertLast(32): $D = [10, 32]$

Step 4: a <- removeFirst(): Removes and returns the first element ( $10$ ). $a = 10$ , $D = [32]$

Step 5: insertLast(28): $D = [32, 28]$

Step 6: insertLast(17): $D = [32, 28, 17]$

Step 7: a <- removeFirst(): Removes and returns the first element ( $32$ ). $a = 32$ , $D = [28, 17]$

Step 8: a <- removeLast(): Removes and returns the last element ( $17$ ). $a = 17$ , $D = [28]$

Step 9: The final value assigned to $a$ is $17$ .

Answer: 17

A question from this chapter

Question 1

Consider the following pseudocode. Create empty stack S Set x=0, flag=0, sum=0 Push x onto S while (S is not empty){ if (flag equals 0){ Set x = x+1 Push x onto S} if (x equals 8): Set flag=1 if (flag equals 1){ x = Pop(S) if (x is odd): Pop(S) Set sum = sum + x} } Output sum The value of sum output by a program executing the above pseudocode is (Answer in integer)

Question 2

Match the items in Column 1 with the items in Column 2 in the following table: Column 1 Column 2 (p) First In First Out (i) Stacks (q) Lookup Operation (ii) Queues (r) Last In First Out (iii) Hash Tables

Question 3

The fundamental operations in a double-ended queue D are: insertFirst(e) - Insert a new element e at the beginning of D. insertLast(e) - Insert a new element e at the end of D. removeFirst() - Remove and return the first element of D. removeLast() - Remove and return the last element of D. In an empty double-ended queue, the following operations are performed: insertFirst(10) insertLast(32) a \leftarrowremoveFirst() insertLast(28) insertLast(17) a \leftarrowremoveFirst() a \leftarrow removeLast() The value of a is ______.

Free preview ends here

Login to view the complete previous-year questions and solutions

Creating an account is free. You get the rest of this chapter, step-by-step solutions, and a study plan built around the topics you are actually weak at.

Why MastersUp

Personalised first. High quality throughout.

Most platforms hand everyone the same content. Here the content moves with your performance, topic by topic.

Built around you, not around a syllabus PDF

Every answer you give moves your topic-level intelligence rate. The next question, the next revision card and tomorrow's plan all change with it.

Revision that hits your weak spots

We only revise topics you have actually attempted and are still below the safe bar on — never the same chapter on repeat.

Questions calibrated to the real exam

Each question carries a measured toughness. You are served a rung above your current level, so practice keeps stretching you.

Notes written for recall, not for volume

Full lesson cards for first study, curated short-note cards for the last mile — with derivations, traps and exam patterns marked.

One place for everything

Notes, chapter practice, previous-year questions, test series and full-length papers — all feeding one picture of your preparation.

Honest progress

No vanity streaks. Progress here means chapters mastered and accuracy that held up on harder questions.

Unlock the whole course

Full notes and short notes, the complete question bank with worked solutions, mock tests, full-length papers, and an adaptive plan that rebuilds itself as you improve.

View all plans Start free

Stacks, Queues and Deques Previous Year Questions (PYQs) for GATE DA: 3+ Solved Questions with Step-by-Step Solutions

Chapter Roadmap: Stacks, Queues, and Deques

Chapter Journey: Linear Data Structures

The Stack Intuition: The Plate Pile

What is a Stack?

Real-World Analogy

Key Terminology

Stacks, Queues and Deques: Solved Questions with Step-by-Step Explanations (3 Problems)

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

More previous year questions (pyqs) in this unit

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