chapter

Stacks, Queues and Linked Lists Short Notes for GATE CS

Stacks, Queues and Linked Lists short notes for GATE CS: 6 study cards covering concepts, formulas, shortcuts and exam traps, plus solved practice questions.

stacks queues and linked lists short notes

Quick Recap: Stack Operations and Augmented Stacks

.c008 { font-family: system-ui, -apple-system, sans-serif; color: var(--color-text); padding: 24px; max-width: 100%; box-sizing: border-box; } .c008 h2 { font-size: 1.4rem; margin: 0 0 20px 0; color: var(--color-primary); } .c008 .section-title { font-size: 0.9rem; font-weight: 600; color: var(--color-muted); text-transform: uppercase; letter-spacing: 0.5px; margin: 20px 0 12px 0; border-bottom: 1px solid var(--color-border); padding-bottom: 4px; } .c008 .takeaway { display: flex; gap: 12px; margin-bottom: 14px; align-items: flex-start; } .c008 .t-icon { flex-shrink: 0; width: 24px; height: 24px; border-radius: 6px; background: color-mix(in srgb, var(--color-primary) 15%, transparent); color: var(--color-primary); display: flex; align-items: center; justify-content: center; font-weight: bold; font-size: 0.8rem; } .c008 .t-text { flex: 1; font-size: 0.85rem; line-height: 1.5; color: var(--color-text); } .c008 .t-text strong { color: var(--color-primary); } .c008 .next-step { margin-top: 24px; padding: 16px; background: color-mix(in srgb, var(--color-primary) 10%, transparent); border-radius: 8px; text-align: center; font-size: 0.9rem; font-weight: 500; border: 1px solid color-mix(in srgb, var(--color-primary) 20%, transparent); } Key Takeaways Core Principles 1 LIFO Principle: Last-In-First-Out governs all stack behavior. 2 Base Operations: push, pop, and peek are inherently . 3 Augmentation: Achieve minimum queries by storing pairs or using an auxiliary min_stack. Execution Rules 4 Tracing: Always maintain a step-by-step state table (Bottom Top for stacks, Front Rear for queues). 5 Constraints: Rigorously check capacity limits before every push to prevent overflow, and check for emptiness before every pop to prevent underflow. 6 Transfers: Remember that moving elements between two stacks reverses their sequence. This foundation prepares you for complex queue and linked list interactions.

Final Revision: Queue and Stack Interactions

Final Revision: Queue and Stack Interactions Core Takeaways FIFO Strictness: Queue access is strictly sequential from front to rear. Stream Splitting: Output = (Stack elements in reverse arrival order) + (Queue elements in original arrival order). Two-Queue Reversal: Requires O (N^{2}) rotations. The destination queue absorbs all Enqueue operations. Counting Trap: If asked for Enqueue operations on the source queue during reversal, the answer is 0.

Formula matrix

#sc-s01{font-family:system-ui,sans-serif;color:var(--color-text);background:var(--color-bg);padding:1rem;border:1px solid var(--color-border);border-radius:6px;line-height:1.4;font-size:0.85rem} #sc-s01 h2{margin:0 0 0.75rem;font-size:1rem;color:var(--color-muted);text-transform:uppercase;letter-spacing:0.05em;border-bottom:2px solid var(--color-primary);display:inline-block;padding-bottom:0.25rem} #sc-s01 .grid{display:grid;grid-template-columns:1.2fr 1fr;gap:1px;background:var(--color-border);border:1px solid var(--color-border);border-radius:4px;overflow:hidden} #sc-s01 .grid>div{background:var(--color-bg);padding:0.4rem 0.6rem} #sc-s01 .grid .h{background:color-mix(in srgb,var(--color-muted) 15%,transparent);font-weight:bold;font-size:0.75rem;text-transform:uppercase} #sc-s01 .grid .accent{background:color-mix(in srgb,var(--color-primary) 10%,transparent);color:var(--color-text)} #sc-s01 code{font-family:monospace;background:color-mix(in srgb,var(--color-muted) 15%,transparent);padding:0.1em 0.2em;border-radius:3px;font-size:0.9em} Formula Matrix Rule / Formula Condition / Bound SLL deletion (given ptr) O (n) | must traverse from head DLL deletion (given ptr) O (1) | prev ptr available SLL deletion (copy data) O (1) | node is NOT tail Iterative reversal assignments 4 n | strictly inside while Recursive reversal space O (n) | call stack depth Safe loop condition curr != NULL | handles empty Unsafe loop condition curr->next != NULL | list non-empty

3 more cards in this chapter

Try a question

Answer it here to see how it works. Nothing is recorded until you sign in.

Question 1

Level 1: Warm-up

An empty stack and an empty queue undergo the following operations: Stack: push(10), push(20), pop(), push(30) Queue: enqueue(10), enqueue(20), dequeue(), enqueue(30) Let S be the sum of elements currently in the stack, and Q be the sum of elements currently in the queue. Which of the following correctly describes the relationship between S and Q ?

Question 2

Level 1: Warm-up

An augmented stack stores pairs of (v a l u e, c u r r e n t_min) to achieve O (1) minimum queries. The current top pair in the stack is (9, 3) . If we push a new arbitrary integer element x, the new top pair will be (x, m) . What is the maximum possible value of m ?

Question 3

Level 1: Warm-up

A stack is initially empty. The following operations are performed in sequence: push(10), push(-5), pop(), push(-3), pop() What is the sum of the values returned by the two pop operations?

Question 4

Level 1: Warm-up

An augmented stack stores pairs of (v a l u e, c u r r e n t_min) . The stack currently contains the following pairs from bottom to top: (10, 10), (5, 5), (8, 5) If we perform push(3), what is the new top pair?

Question 5

Level 1: Warm-up

Which of the following statements is TRUE regarding reversing a queue Q_{1} of N elements into Q_{2} using ONLY Enqueue and Dequeue operations?

Question 6

Level 1: Warm-up

Consider the following Assertion (A) and Reason (R): Assertion (A): In the two-queue reversal algorithm for N elements, the total number of Enqueue operations performed on Q_{2} is \frac{N ( N + 1 )}{2} . Reason (R): Q_{2} acts as both the destination for the N elements from Q_{1} and the buffer for rotating the already placed elements. Select the correct option:

Question 7

Level 1: Warm-up

Which of the following statements is TRUE regarding the reversal of a queue Q_{1} of N elements into an empty queue Q_{2} using ONLY Enqueue and Dequeue operations on Q_{1} and Q_{2} ?

Question 8

Level 1: Warm-up

Consider the following Assertion (A) and Reason (R): Assertion (A): In the two-queue reversal algorithm for N elements, the total number of Dequeue operations performed on the destination queue Q_{2} is \frac{N ( N - 1 )}{2} . Reason (R): For each of the N elements moved from Q_{1} to Q_{2}, it must be cycled past the elements already in Q_{2}, requiring a number of Dequeue operations on Q_{2} equal to the current size of Q_{2} . Select the correct option:

Question 9

Level 1: Warm-up

Match the operation with its minimum count when reversing an N -element queue Q_{1} into an empty queue Q_{2} using ONLY Enqueue and Dequeue operations on Q_{1} and Q_{2} . List-I (Operation) P. Enqueue operations on Q_{1} Q. Dequeue operations on Q_{1} List-II (Count) 0 N \frac{N ( N + 1 )}{2}

Question 10

Level 1: Warm-up

Consider the following sequence of operations performed on an initially empty stack: push, push, pop, push, pop, pop A student claims that the stack becomes empty exactly 3 times during this sequence. What is the actual minimum number of times the stack becomes empty?

Free preview ends here

Login to view the complete short notes

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 Linked Lists Short Notes for GATE CS

Stacks, Queues and Linked Lists short notes for GATE CS: 6 study cards covering concepts, formulas, shortcuts and exam traps, plus solved practice questions.

Quick Recap: Stack Operations and Augmented Stacks

Key Takeaways

Core Principles

LIFO Principle: Last-In-First-Out governs all stack behavior.

Base Operations: push, pop, and peek are inherently

O (1)

Augmentation: Achieve

O (1)

minimum queries by storing

(v a l u e, min)

pairs or using an auxiliary min_stack.

Execution Rules

Tracing: Always maintain a step-by-step state table (Bottom

\to

Top for stacks, Front

\to

Rear for queues).

Constraints: Rigorously check capacity limits before every push to prevent overflow, and check for emptiness before every pop to prevent underflow.

Transfers: Remember that moving elements between two stacks reverses their sequence.

This foundation prepares you for complex queue and linked list interactions.

Final Revision: Queue and Stack Interactions

Core Takeaways

FIFO Strictness: Queue access is strictly sequential from front to rear.
Stream Splitting: Output = (Stack elements in reverse arrival order) + (Queue elements in original arrival order).
Two-Queue Reversal: Requires $O (N^{2})$ rotations. The destination queue absorbs all Enqueue operations.
Counting Trap: If asked for Enqueue operations on the source queue during reversal, the answer is 0.

Formula matrix

Formula Matrix

Rule / Formula

Condition / Bound

SLL deletion (given ptr)

O (n)

| must traverse from head

DLL deletion (given ptr)

O (1)

| prev ptr available

SLL deletion (copy data)

O (1)

| node is NOT tail

Iterative reversal assignments

4 n

| strictly inside while

Recursive reversal space

O (n)

| call stack depth

Safe loop condition

curr != NULL | handles empty

Unsafe loop condition

curr->next != NULL | list non-empty

If you see this, do this

If You See This, Do This

Stem Trigger

First Move

"insert without losing list"

newNode->next = curr->next; curr->next = newNode;

"delete SLL node given ptr"

Traverse from head to find prev, then prev->next = target->next;

"recursive list size base case"

if (head == NULL) return 0;

"recursive deletion step"

head->next = deleteX(head->next, X); return head;

"post-loop pointer access"

Check if loop terminates at NULL; accessing ptr->val causes segfault.

"splice L1 to L2"

Traverse L1 to curr->next == NULL, then curr->next = L2; (check L1 non-empty).

"count nodes after rewire"

Trace from head, stop at NULL, ignore orphaned nodes.

Stacks, Queues and Linked Lists: Solved Questions with Step-by-Step Explanations (10 Problems)

Question 1 · Programming and Data Structures MCQ

An empty stack and an empty queue undergo the following operations:

Stack: push(10), push(20), pop(), push(30)

Queue: enqueue(10), enqueue(20), dequeue(), enqueue(30)

Let $S$ be the sum of elements currently in the stack, and $Q$ be the sum of elements currently in the queue. Which of the following correctly describes the relationship between $S$ and $Q$ ?

A.
$S = Q$
B.
$S > Q$
C.
$S < Q$
D.
$S = 2 Q$

Correct Answer:

Step-by-Step Solution

Key idea: This is a bounding question testing the fundamental difference between LIFO (stack) and FIFO (queue) removal constraints.

Step 1: Trace the Stack (LIFO).

push(10) $\to$ [10]
push(20) $\to$ [10, 20]
pop() $\to$ removes 20 (top). Stack is [10]
push(30) $\to$ [10, 30]
Sum $S = 10 + 30 = 40$ .

Step 2: Trace the Queue (FIFO).

enqueue(10) $\to$ [10]
enqueue(20) $\to$ [10, 20]
dequeue() $\to$ removes 10 (front). Queue is [20]
enqueue(30) $\to$ [20, 30]
Sum $Q = 20 + 30 = 50$ .

Step 3: Compare $S$ and $Q$ . $40 < 50$ , so $S < Q$ .

Answer: $S < Q$

Question 2 · Programming and Data Structures MCQ

An augmented stack stores pairs of $(v a l u e, c u r r e n t_min)$ to achieve $O (1)$ minimum queries. The current top pair in the stack is $(9, 3)$ . If we push a new arbitrary integer element $x$ , the new top pair will be $(x, m)$ . What is the maximum possible value of $m$ ?

A.
$x$
B.
9
C.
3
D.
0

Correct Answer:

Step-by-Step Solution

Key idea: This is an observation question testing the boundary condition of the augmented stack's minimum tracking logic.

Step 1: Recall the rule for the pair approach: when pushing $x$ , the new minimum $m$ is calculated as $m = min (x, c u r r e n t_min)$ .

Step 2: The current minimum (the second element of the top pair) is 3.

Step 3: Therefore, $m = min (x, 3)$ .

Step 4: By the definition of the minimum function, $min (x, 3)$ can never exceed 3, regardless of how large $x$ is. The maximum possible value for $m$ is exactly 3.

Answer: 3

Question 3 · Programming and Data Structures MCQ

A stack is initially empty. The following operations are performed in sequence:

push(10), push(-5), pop(), push(-3), pop()

What is the sum of the values returned by the two pop operations?

A.
8
B.
-8
C.
2
D.
-2

Correct Answer:

Step-by-Step Solution

Key idea: This is a basic LIFO tracing question testing careful handling of negative numbers during sequential operations.

Step 1: push(10) $\to$ Stack: [10]

Step 2: push(-5) $\to$ Stack: [10, -5]

Step 3: pop() $\to$ Removes and returns -5. Stack: [10]

Step 4: push(-3) $\to$ Stack: [10, -3]

Step 5: pop() $\to$ Removes and returns -3. Stack: [10]

Step 6: Sum the returned values: $(- 5) + (- 3) = - 8$ .

Answer: -8

Question 4 · Programming and Data Structures MCQ

An augmented stack stores pairs of $(v a l u e, c u r r e n t_min)$ . The stack currently contains the following pairs from bottom to top:

$(10, 10), (5, 5), (8, 5)$

If we perform push(3), what is the new top pair?

A.
(3, 3)
B.
(3, 5)
C.
(3, 10)
D.
(8, 3)

Correct Answer:

Step-by-Step Solution

Key idea: This is an augmented stack question. When pushing a new value, the current_min is updated as min(new_value, previous_min).

Step 1: Identify the current state.

Stack from bottom to top: (10, 10), (5, 5), (8, 5)
Current top pair: (8, 5)
Current minimum: 5 (from the top pair's second element)

Step 2: Perform push(3).

New value: 3
Previous minimum: 5
New minimum: min(3, 5) = 3

Step 3: Form the new top pair.

New pair: (value, new_min) = (3, 3)

Step 4: Update the stack.

Stack from bottom to top: (10, 10), (5, 5), (8, 5), (3, 3)
New top pair: (3, 3)

Answer: A

Question 5 · Programming and Data Structures MCQ

Which of the following statements is TRUE regarding reversing a queue $Q_{1}$ of $N$ elements into $Q_{2}$ using ONLY Enqueue and Dequeue operations?

A.
The time complexity of the reversal is strictly bounded by $O (N)$ .
B.
Every element is dequeued from $Q_{1}$ exactly once.
C.
An auxiliary stack is used to temporarily store elements during rotation.
D.
The total number of enqueue operations on $Q_{2}$ is exactly $N$ .

Correct Answer:

Step-by-Step Solution

Key idea: This is a bounding question testing the time complexity and operation constraints of two-queue reversal.

Step 1: Analyze the constraint. The problem specifies "using ONLY Enqueue and Dequeue operations". This explicitly forbids auxiliary data structures like stacks.

Step 2: Evaluate option A. Reversing a queue using two queues requires cycling elements, which strictly bounds the time complexity at $O (N^{2})$ , not $O (N)$ .

Step 3: Evaluate option B. $Q_{1}$ acts strictly as the source. To move all $N$ elements to $Q_{2}$ , every element must be dequeued from $Q_{1}$ exactly once. This is true.

Step 4: Evaluate option C. This violates the "ONLY Enqueue and Dequeue" constraint.

Step 5: Evaluate option D. $Q_{2}$ receives $N$ elements from $Q_{1}$ , plus additional enqueues during rotation. The total enqueues on $Q_{2}$ is $\frac{N ( N + 1 )}{2}$ , not $N$ .

Answer: B

Question 6 · Programming and Data Structures MCQ

Consider the following Assertion (A) and Reason (R):

Assertion (A): In the two-queue reversal algorithm for $N$ elements, the total number of Enqueue operations performed on $Q_{2}$ is $\frac{N ( N + 1 )}{2}$ .

Reason (R): $Q_{2}$ acts as both the destination for the $N$ elements from $Q_{1}$ and the buffer for rotating the already placed elements.

Select the correct option:

A.
Both A and R are true, and R is the correct explanation of A.
B.
Both A and R are true, but R is NOT the correct explanation of A.
C.
A is true, but R is false.
D.
A is false, but R is true.

Correct Answer:

Step-by-Step Solution

Key idea: This is a construction question validating the logical relationship between the roles of $Q_{1}$ and $Q_{2}$ .

Step 1: Construct the mental model of the two-queue reversal algorithm. $Q_{1}$ is the source, $Q_{2}$ is the destination and rotation buffer.

Step 2: Evaluate Assertion (A). For each of the $N$ elements moved from $Q_{1}$ , the elements already in $Q_{2}$ must be cycled (dequeued and enqueued back to $Q_{2}$ ) to maintain the reversed order. The total enqueues on $Q_{2}$ sum to $1 + 2 + \dots + N = \frac{N ( N + 1 )}{2}$ . Assertion (A) is true.

Step 3: Evaluate Reason (R). $Q_{2}$ indeed absorbs all elements from $Q_{1}$ and also handles the rotation enqueues. Reason (R) is true.

Step 4: Check the explanatory link. Reason (R) perfectly describes the mechanical roles that cause the mathematical sum in Assertion (A). Therefore, R is the correct explanation of A.

Answer: A

Question 7 · Programming and Data Structures MCQ

Which of the following statements is TRUE regarding the reversal of a queue $Q_{1}$ of $N$ elements into an empty queue $Q_{2}$ using ONLY Enqueue and Dequeue operations on $Q_{1}$ and $Q_{2}$ ?

A.
The time complexity is $O (N)$ because each element is transferred directly from $Q_{1}$ to $Q_{2}$ .
B.
The algorithm requires an auxiliary stack to temporarily hold elements during cycling.
C.
The total number of Dequeue operations performed on $Q_{1}$ is exactly $N$ .
D.
The total number of Enqueue operations performed on $Q_{1}$ is $N$ .

Correct Answer:

Step-by-Step Solution

Key idea: This is a bounding question testing the constraints and mechanics of two-queue reversal.

Step 1: Analyze the constraint. The problem specifies "using ONLY Enqueue and Dequeue operations on $Q_{1}$ and $Q_{2}$ ". This explicitly forbids auxiliary data structures like stacks or arrays.

Step 2: Evaluate the roles. $Q_{1}$ starts with $N$ elements and acts strictly as the source. It only loses elements via Dequeue operations. It never receives elements back.

Step 3: Bound the operations. To empty $Q_{1}$ completely, exactly $N$ Dequeue operations must be performed on it. Therefore, the statement "The total number of Dequeue operations performed on $Q_{1}$ is exactly $N$ " is true.

Step 4: Evaluate other options. Option A is false because cycling requires $O (N^{2})$ time. Option B is false because it violates the "ONLY Enqueue and Dequeue" constraint. Option D is false because $Q_{1}$ receives 0 Enqueue operations.

Answer: C

Question 8 · Programming and Data Structures MCQ

Consider the following Assertion (A) and Reason (R):

Assertion (A): In the two-queue reversal algorithm for $N$ elements, the total number of Dequeue operations performed on the destination queue $Q_{2}$ is $\frac{N ( N - 1 )}{2}$ .

Reason (R): For each of the $N$ elements moved from $Q_{1}$ to $Q_{2}$ , it must be cycled past the elements already in $Q_{2}$ , requiring a number of Dequeue operations on $Q_{2}$ equal to the current size of $Q_{2}$ .

Select the correct option:

A.
Both A and R are true, and R is the correct explanation of A.
B.
Both A and R are true, but R is NOT the correct explanation of A.
C.
A is true, but R is false.
D.
A is false, but R is true.

Correct Answer:

Step-by-Step Solution

Key idea: This is a construction question validating the logical relationship between the cycling mechanics and operation counts.

Step 1: Construct the mental model of the two-queue reversal algorithm.

$Q_{1}$ starts with $N$ elements. It acts strictly as the source.
$Q_{2}$ starts empty. It acts as the destination and the rotation buffer.

Step 2: Evaluate Reason (R). When the $k$ -th element is moved from $Q_{1}$ to $Q_{2}$ , there are already $k - 1$ elements in $Q_{2}$ . To place the new element at the front (relative to the final reversed order), the existing $k - 1$ elements must be cycled. Cycling $k - 1$ elements requires exactly $k - 1$ Dequeue operations on $Q_{2}$ . Reason (R) is true.

Step 3: Evaluate Assertion (A). The total number of Dequeue operations on $Q_{2}$ is the sum of Dequeues for each of the $N$ elements: $0 + 1 + 2 + \dots + (N - 1) = \frac{N ( N - 1 )}{2}$ . Assertion (A) is true.

Step 4: Check the explanatory link. Reason (R) perfectly describes the mechanical cause that directly results in the mathematical sum stated in Assertion (A). Therefore, R is the correct explanation of A.

Answer: A

Question 9 · Programming and Data Structures MCQ

Match the operation with its minimum count when reversing an $N$ -element queue $Q_{1}$ into an empty queue $Q_{2}$ using ONLY Enqueue and Dequeue operations on $Q_{1}$ and $Q_{2}$ .

List-I (Operation)

P. Enqueue operations on $Q_{1}$

Q. Dequeue operations on $Q_{1}$

List-II (Count)

$0$
$N$
$\frac{N ( N + 1 )}{2}$

A.
P-1, Q-2
B.
P-2, Q-1
C.
P-1, Q-3
D.
P-3, Q-2

Correct Answer:

Step-by-Step Solution

Key idea: In the standard two-queue reversal algorithm, $Q_{1}$ acts strictly as the source and $Q_{2}$ as the destination.

Step 1: Since $Q_{1}$ is only the source, elements are only removed from it. Thus, it undergoes exactly $N$ Dequeue operations.

Step 2: No elements are ever added back to $Q_{1}$ . Therefore, the number of Enqueue operations on $Q_{1}$ is exactly $0$ .

Answer: P matches with 1, and Q matches with 2.

Question 10 · Programming and Data Structures MCQ

Consider the following sequence of operations performed on an initially empty stack:

push, push, pop, push, pop, pop

A student claims that the stack becomes empty exactly 3 times during this sequence. What is the actual minimum number of times the stack becomes empty?

A.
3
B.
2
C.
1
D.
0

Correct Answer:

Step-by-Step Solution

Key idea: This is a contradiction question testing precise step-by-step tracing against a flawed mental model of stack emptiness.

Step 1: Trace the stack size step-by-step.

push $\to$ size 1
push $\to$ size 2
pop $\to$ size 1
push $\to$ size 2
pop $\to$ size 1
pop $\to$ size 0 (Stack is empty. Count = 1)

Step 2: Evaluate the student's claim. The student likely counted every pop operation as an event that makes the stack empty.

Step 3: The stack only reaches size 0 once, at the very end.

Answer: 1

stacks queues and linked lists short notes

Quick Recap: Stack Operations and Augmented Stacks

Key Takeaways

Final Revision: Queue and Stack Interactions

Final Revision: Queue and Stack Interactions

Core Takeaways

Formula matrix

Formula Matrix

Try a question

Login to view the complete short notes

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

Stacks, Queues and Linked Lists Short Notes for GATE CS

Quick Recap: Stack Operations and Augmented Stacks

Key Takeaways

Final Revision: Queue and Stack Interactions

Final Revision: Queue and Stack Interactions

Core Takeaways

Formula matrix

Formula Matrix

If you see this, do this

If You See This, Do This

Stacks, Queues and Linked Lists: Solved Questions with Step-by-Step Explanations (10 Problems)

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

More short notes in this unit