Data structure(Stack) MCQ

enter the output for the code

LETSFINDC

declare a stack of characters

while(there are more characters in the word)

{

read a ch

push the ch on the stack}

while(stack in not empty)

{

pop a ch off the stack

print on screen

}

The following sequence of operations is performed on stack: PUSH (10),PUSH (20),POP,PUSH (10),PUSH (20),POP,POP,POP,PUSH (20),POP The sequence of the value popped out is

• 10,20,20,10,20

• 20,20,10,20,10

• 20,10,20,10,20

• 20,20,10,10,20

processes of inserting an element in stack is called?

• push

• pop

• delete

• none of these

Consider the following sequence of operations on an empty stack.

push(54); push(52); pop(); push(55); push(62); s = pop();

Consider the following sequence of operations on an empty queue.

enqueue(21); enqueue(24); dequeue(); enqueue(28); enqueue(32); q = dequeue();

The value of s + q is ______

• 76

• 96

• 64

• 86

the process of accessing data stored in a serial access memory is similar to manipulating data on a

The postfix expression for the infix expression A + B (C + D) / F + D E is

• AB+CD+*F/D+E*

• ABCD+*F/+DE*+

• A*B+CD/F*DE++

• A+*BCD/F*DE++

Entries in a stack are “ordered”. What is the meaning of this statement?

• A collection of stacks is sortable

• Stack entries may be compared with the ‘<‘ operation

• The entries are stored in a linked list

• There is a Sequential entry that is one by one

declare a character stack

while ( more input is available)

{

read a character

if ( the character is a '(' )

push it on the stack

else if ( the character is a ')' and the stack is not empty )

pop a character off the stack

else

print "unbalanced" and exit

}

print "balanced"

• ((())

• ())(()

• (()()))

• (()))()

Consider the following stack implemented using stack.

#define SIZE 11

struct STACK

{

int arr[SIZE];

int top=-1;

}

What would be the maximum value of the top that does not cause the overflow of the stack?

8

9

11

10

• 8

• 9

• 11

• 10

Answer explanation

The answer is 10. The maximum size of the array is 11; therefore, we can insert 11 elements in the stack. The top value is initialized by -1, and on every insertion, the top value gets incremented.

Following is C like pseudo code of a function that takes a number as an argument, and uses a stack S to do processing.

void fun(int n)

{

Stack S; // Say it creates an empty stack S

while (n > 0)

{

// This line pushes the value of n%2 to stack S

push(&S, n%2);

n = n/2;

}

// Run while Stack S is not empty

while (!isEmpty(&S))

printf("%d ", pop(&S)); // pop an element from S and print it

}

• Prints binary representation of n in reverse order

• Prints binary representation of n

• Prints the value of Logn

• Prints the value of Logn in reverse order