Test: Arrays, Stack, Queues & Linked List- 3 - Computer Science Engineering (CSE) MCQ

There are 500 students the score range is 0 to 100. Print the frequency of those student whose score above 50. So frequency range contains score from 50 to 100, so an array of 50 numbers is suitable for representing the frequency.

∴ The sequence of values popped out is 20, 20, 10, 10, 20.

PUSH one by one element into Stack and POP accordingly desired output. Only second option can satisfy.

Infix: A + B*(C + D)/F + D*E
Postfix: ABCD + *F/ + DE*++

Stack is UFO system so FIFO not supported by stack hence option statement 1 is incorrect and queue is using FIFO so statement 4 is also wrong.

Operands never change its position during expression conversion so only operator stack is needed.

In stack last element will be deleted first but according to question, it should be wprk like queue. So last element deleted at last, for that we give lower priority to last element. So all elements should be in strictly decreasing order.

So the return value is 91.

The stack is a data structure in which each push (insert) or pop (delete) operation takes constant 0(1) time. The best data structure to check whether an arithmetic expression has a balanced parentheses.
Step 1: Start with empty stack of currently open parentheses.
Step 2: Process each char of an expression string.
Step 3: If it is open, push it on the stack.
Step 4: If it is closed, check it against the top of stack element.
Step4.1: If stack empty or not a matching parentheses then not balanced and return false.
Step 4.2: Otherwise it matches, pop the open parentheses then goto step 2.
Step 5: If stack is empty at the end, return true.
Step 6: If not empty then some parentheses is unmatched, return false.

To add a new node:

new → next = Rear → next;
Rear → next = new;
Rear = new;

It will take constant time.
Similarly delete node from Front code will be:
Front = Rear → next;
Rear → next = Front → next;
Free (Front);
It will also take constant time.

According to conditions given:
⇒ [(a + (b x c)) - (d ^ (e ^ f))]
⇒ [(a + ( b c x)) - (d ^ (e f ^))]
⇒ [(abc x +) - (def^^)]
⇒ abc x + def^^ -

• For every element push an element and pop immediately i.e. push (a) then pop will give permutation abed.
• For all elements push (a), push (b), push (c) and push (d) then pop, pop, pop, pop will give us deba.
• Push (a), push (b), push (c) then pop, pop, pop will give is eba, then push (d) and pop will gives us deba.
• Option (d) is not possible because a cannot pop after c and before ‘b’.

Given postfix expression is
8 2 3 ^ / 23 * + 5 1 * -

So the top two elements of the stack are 6, 1 after the first * is evaluated.

Consider an queue with elements inserted in same order as element present in queue.

Now to implement stack same as queue:


A queue can be implemented where ENQUEUE takes a sequence of three instructions and DEQUEUE takes a single instruction.

10 5 + 60 6 / * 8 -

Result is 142.

In above linked list a new record X wili be inserted in between B and C.

Two pointers are modified to insert X record.

Using linked list binary search wili take O(n) time. So binary search is inefficient with linked list.

Linear search number of comparisons: O(n).

For a given linked list p, the function f returns 1 if and only if the eiements in the list are stored in non-decreasing (increasing) order of the data value.
f returns 1 if p == NULL or p Next == NULL or p → data < = p → next data, satisfies in linked list for every node p.