Stack MCQ Quiz - Objective Question with Answer for Stack - Download Free PDF

The correct answer is ab + cd*e - fg*/*.

Key Points

• To convert an infix expression to its postfix equivalent, follow the order of operations and use a stack to manage the operators.
• The given infix expression is (a + b)*(c*d - e) * f/g.
  • First, evaluate the expression inside the parentheses: a + b and c*d - e.
  • The postfix notation for a + b is ab+.
  • The postfix notation for c*d - e is cd*e-.
  • Next, multiply the results of these two expressions: (ab+)(cd*e-).
  • The postfix notation for this multiplication is ab+cd*e-*.
  • Finally, multiply by f and divide by g: (ab+cd*e-)*f/g.
  • The postfix notation for this final expression is ab+cd*e-*f*g/.
• Therefore, the postfix equivalent of the infix expression (a + b)*(c*d - e) * f/g is ab+cd*e-*f*g/.

Additional Information

• Infix notation is the standard arithmetic and logical formula notation, where operators are placed between operands (e.g., a + b).
• Postfix notation (also known as Reverse Polish Notation) places operators after their operands (e.g., ab+).
• Postfix notation eliminates the need for parentheses to define operation order.
• This method is particularly useful in computer science for evaluating expressions in a stack-based manner.

The correct answer is 1100.

Key Points

• To evaluate a postfix expression, follow these steps:
  • Read the expression from left to right.
  • Push operands onto a stack.
  • When an operator is encountered, pop the required number of operands from the stack, perform the operation, and push the result back onto the stack.
• Let's evaluate the given postfix expression step-by-step: 50, 60, +, 20, 10, -, *
  • Push 50 onto the stack.
  • Push 60 onto the stack.
  • Encounter '+', pop 60 and 50, add them (50 + 60 = 110), push 110 onto the stack.
  • Push 20 onto the stack.
  • Push 10 onto the stack.
  • Encounter '-', pop 10 and 20, subtract them (20 - 10 = 10), push 10 onto the stack.
  • Encounter '*', pop 10 and 110, multiply them (110 * 10 = 1100), push 1100 onto the stack.
• After processing all elements, the final value on the stack is 1100, which is the result of the postfix expression.

Additional Information

• Postfix expressions, also known as Reverse Polish Notation (RPN), do not require parentheses to dictate operation precedence.
• They are often used in computer science because they can be easily evaluated using a stack, which simplifies the parsing process.
• Postfix notation is particularly useful in situations where the order of operations needs to be explicitly defined and consistently followed.
• Commonly used in stack-based and expression evaluation algorithms in compilers and calculators.

The correct answer is option 2.

Key Points

A stack is a LIFO (Last-In, First-Out) data structure. This means the last element pushed onto the stack is the first one to be popped off.

Given Operations:

1. PUSH(10) → Stack: [10]
2. PUSH(20) → Stack: [10, 20]
3. POP() → Removes 20 → Stack: [10]
4. POP() → Removes 10 → Stack: []
5. PUSH(30) → Stack: [30]
6. PUSH(40) → Stack: [30, 40]
7. POP() → Removes 40 → Stack: [30]
8. POP() → Removes 30 → Stack: []

Sequence of removed elements:

1. 20
2. 10
3. 40
4. 30

Corresponding to the options:

• (A) 10
• (B) 20
• (C) 30
• (D) 40

Sequence: (B), (A), (D), (C)

Hence, the correct answer is: option 2

The correct answer is Last In First Out.

Key Points

• A stack is a data structure that works on the principle of Last In First Out (LIFO).
  • In this structure, the last element added to the stack is the first one to be removed.
  • This principle is analogous to a stack of plates: you add a plate to the top of the stack, and you also remove the topmost plate first.
  • Stacks are used in various applications, including function call management in programming, undo mechanisms in text editors, and parsing expressions in compilers.
  • Common operations associated with stacks are push (adding an element) and pop (removing an element).
  • Other stack operations include peek (viewing the top element without removing it) and isEmpty (checking if the stack is empty).

Additional Information

• Stacks are implemented using arrays or linked lists.
• They provide an efficient way to manage data, with a time complexity of O(1) for both push and pop operations.
• Some common examples of stack usage in computer science include the evaluation of arithmetic expressions, reversing strings, and depth-first search algorithms.
• The concept of stack is fundamental in computer science and is crucial for understanding other advanced data structures and algorithms.

The correct answer is 39.

Key Points

• To evaluate the given postfix expression 3 5 * 6 + 2 3 * -, follow these steps:
  • Start with the expression: 3 5 * 6 + 2 3 * -
  • First, perform the multiplication: 3 * 5 = 15
  • The expression now becomes: 15 6 + 2 3 * -
  • Next, perform the addition: 15 + 6 = 21
  • The expression now becomes: 21 2 3 * -
  • Next, perform the multiplication: 2 * 3 = 6
  • The expression now becomes: 21 6 -
  • Finally, perform the subtraction: 21 - 6 = 15
  • Thus, the final result of the postfix expression 3 5 * 6 + 2 3 * - is 15.

Additional Information

• Postfix notation, also known as Reverse Polish Notation (RPN), is a mathematical notation in which every operator follows all of its operands.
• It is used because it can easily be evaluated using a stack data structure, which makes it very efficient for computer processing.
• In postfix notation, there is no need for parentheses to define the order of operations as the position of the operators and operands dictates the order in which the operations are performed.
• This method is widely used in calculators and computer algorithms for parsing arithmetic expressions.

The correct answer is option 2.

Concept:

Concept:

​Prefix:

A Prefix expression prints the operator operand 1, and operand 2 respectively.

Explanation:

The given prefix is  +, -, *, 3, 2, /, 8, 4, 1.

Hence the correct answer is 5.

Concept:

() has highest precedence

* and / has same precedence while + and – has same precedence

(* and /) and higher precedence than (+, -)

Associativity is left to right:

Explanation:

(A + B) * C – D * E / F

A B + * C – D * E / F

A B + C * – D * E / F

A B + C * – D E * / F

A B + C * – D E * F /

A B + C * D E * F / –

Calculation:

Postfix expression 10 5 + 60 6 / * 8 −

PUSH: 10 and 5(TOS)

Add: 10 + 5 = 15

PUSH: 15 60 6 (TOS)

Divide: 60/6 = 10

PUSH: 10

Multiply: 15 × 10 = 150

PUSH: 150 and 8

Subtract: 150 - 8 = 142

Diagram:

Evaluate Infix notation:

(((10 + 5) * (60 / 6)) - 8)  = ((15 * 10) - 8) = 150 - 8 = 142

The correct answer is Which is entered at last 

Key Points

• Stack is LIFO type data structure. LIFO stands for Last-in-first-out.
• Here, the element which is placed (inserted or added) last, is accessed first.
• In stack terminology, insertion operation is called PUSH operation and removal operation is called POP operation.
• We can see push(insertion) and POP(removal) both are occurring at top of stack.

In the given example we have inserted “6” in the last but removed “6” first. This is LIFO operation.

Concept:

Stack:

Stack is a linear data structure that allows to insert or delete elements from one end i.e. from the top of the stack. It follows a particular order in which elements are inserted or deleted i.e. LIFO (Last in first out).

Queue:

Queue is a linear data structure in which elements are inserted from one end and deleted from the other ends. It follows FIFO property i.e. first in first out.

Explanation:

Given five items P, Q, R, S, and T.

These are pushed into the stack as : 

Now stack is popped four times, and each item popped is inserted into the queue.

So, items that are popped from the stack are: T, S, R, Q

After insertion into queue, queue looks like this:

Now, two items are deleted from the queue which is: T, S

These are inserted back into the stack.

Stack will be :

Queue will be :

Now, one item is popped from the stack which is S.

Postfix expression: 6 2 3 * / 4 2 * + 6 8 * -

Concept:

• A stack is an ordered list in which insertion and deletion are done at one end, called a top.
• The last element inserted is the first one to be deleted. Hence, it is called the Last in First out (LIFO) or First in Last out (FILO) list.

Explanation:

A recursive problem like the Tower of Hanoi can be rewritten using system stack or user-defined stack

Recurrence relation of tower of Hanoi:  T(n) = 2T(n - 1) + 1 

Additional Information

Number of moves required for n disc in a Tower of Hanoi is 2n – 1 = 27 – 1 = 127. 

Stack underflow happens when one tries to pop (remove) an item from the stack when nothing is actually there to remove.

Concept:

Usually, the empty stack is initialized with value 0 and this value increments by 1 every time we push an element on to the stack.

The code for such a stack looks like this,

push (x)

                A[pos] ← x

                pos ← pos + 1 /the initial value is incremented by 1 as element is pushed onto the stack

end push

However, in the question, when push operation takes place, the value of variable is decremented by 1 (pos – 1).  Hence, initial value of pos will have to be N-1.

Explanation

For example, if we take an array with N = 4 to represent our stack. It will be A [0, 1, 2, 3].

Now, in order to push four elements, say x, y, z, w

• First we will push at x index 3 which is 4 – 1
• Then, we will decrement pos and push y at index 2 and so on.

Note that, the pop operation is also behaving inversely here.

• In usual stack, pop would decrement value of pos.

The correct answer is option 4.

Concept:

Infix:

An infix expression prints the operand 1, operator, and operand 2 respectively.

Postfix:

A Postfix expression prints the operand 1, operand 2, and operator respectively.

Prefix:

A Prefix expression prints the operator operand 1, and operand 2 respectively.

Converse postfix:

A converse postfix expression prints the operand 2, operand 1, and operator respectively.

Converse infix:

A converse infix expression prints the operand 2,  operator, and operand 1 respectively.

Converse prefix:

A converse prefix expression prints the operator, operand 2, and operand 1  respectively.

Explanation:

The given infix is, 

(a+(b/c) *(d^e)-f)

() is highest prority

The inner (b/c) is excutes first,

operand 1=b

operand 2=c

Operator= /

(a+/bc *(d^e)-f)

The inner (d^e) is excutes next,

operand 1=d

operand 2=e

Operator= ^

(a+/bc *^de-f)

The highest operator is * than +, -

operand 1=/bc

operand 2=^de

Operator= *

(a+*/bc^de-f)

The highest operator is + than -.

operand 1=a 

operand 2= */bc^de

Operator= +

(+a*/bc^de-f)

operand 1=+a*/bc^de

operand 2= f

Operator= There is no start phase in Virus Life Cycle.

The prefix is -+a*/bc^def.

Hence the correct answer is -+a*/bc^def.

A stack can be implemented using two queues. Let stack to be implemented be ‘x’ and queues used to implement be ‘a’ and ‘b’.

Method 1 (By push operation)
This method makes sure that the newly entered element is always at the front of ‘a’, so that pop operation just dequeues from ‘a’. ‘b’ is used to put every new element at front of ‘b’.