Arrays, Stack, Queues & Linked List- 3 - Free MCQ Practice Test with solutions,

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.

Option B is correct.

Handle the parenthesised subexpression first; it becomes CD+.

Apply multiplication of the preceding operand with that result to get BCD+*.

Divide that result by the next operand to obtain BCD+*F/.

Add the first operand to this intermediate result producing ABCD+*F/+.

Form the postfix for the other multiplication as DE*.

Finally, add the two postfix parts to obtain ABCD+*F/+DE*+, which matches Option B.

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.

Answer: A

Pointer p should point to the rear node. In a circular linked list the front node is the node rear->next, so both insertion at rear and deletion from front can be done using only p.

For enQueue (insert at rear), using only p (pointing to rear):

Create the new node: new.

new->next = p->next;

p->next = new;

p = new;

Each of these steps accesses or updates a fixed number of pointers, so enQueue is done in O(1) time.

For deQueue (delete from front), using only p (pointing to rear):

temp = p->next; (temp is the front node)

p->next = temp->next;

free(temp);

These steps also perform a fixed number of pointer operations, so deQueue is done in O(1) time.

Therefore, with p pointing to the rear node, both operations run in O(1). If p pointed to front, enQueue would require locating rear (an O(n) traversal), so that would not give constant-time insertion.

Hence, p must point to the rear node.

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.