46th BCS Technical, Written (CSE-971), Time: 4 hours, Full Marks: 200, Exam: 2025প্রশ্ন ও সমাধান

Call by value passes a copy of the argument's value to the function — changes made inside the function stay local and the caller's original variable is untouched. Call by reference passes the address/alias of the actual variable — changes made through that reference are reflected in the caller's variable itself.

Aspect	Call by Value	Call by Reference
What is passed	A copy of the value	The address (alias) of the variable
Effect on caller's variable	No change	Variable is modified
Memory	Separate copy created	Same memory location used
C implementation	Plain parameters	Pointers (*)

C program — swap using call by reference (pointers):

#include <stdio.h>

void swap(int *a, int *b) {   // receives addresses
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before: x=%d, y=%d\n", x, y);
    swap(&x, &y);              // pass addresses -> call by reference
    printf("After:  x=%d, y=%d\n", x, y);
    return 0;
}

Output:

Before: x=5, y=10
After:  x=10, y=5

Here swap dereferences the pointers (*a, *b) to reach x and y directly in the caller's memory, so the swap persists after the function returns — which a plain swap(int a, int b) (call by value) could never do.

Exam takeaway: use call by reference (pointers/references) whenever a function must modify the caller's original data, such as swap, or returning multiple values.

A linear data structure arranges elements sequentially, where each element (except the first/last) has exactly one predecessor and one successor — traversal is single-pass. A non-linear data structure arranges elements hierarchically or in a network, where an element may connect to multiple others, so traversal can branch.

graph LR
subgraph Linear
A1[10] --> A2[20] --> A3[30] --> A4[40]
end
subgraph NonLinear
B1((Root)) --> B2((Left))
B1 --> B3((Right))
B2 --> B4((L.L))
B2 --> B5((L.R))
end

Aspect	Linear	Non-Linear
Arrangement	Sequential, single level	Hierarchical/networked, multiple levels
Traversal	One pass (front to back)	Multiple paths (DFS/BFS, in/pre/post-order)
Memory utilization	Simple, often contiguous	Complex, pointer-heavy
Examples	Array, Linked List, Stack, Queue	Tree, Graph, Heap
Implementation complexity	Low	Higher

Use cases:

• Array/Linked List: ordered records, playlists, undo history (Stack), print/task scheduling (Queue).
• Tree: file systems, database indexes (B-Trees), decision-making (Decision Trees), hierarchical org charts.
• Graph: road/social networks, routing tables, dependency resolution.

Exam takeaway: choose linear structures when data has a natural sequence and simple access patterns; choose non-linear structures when relationships between elements are hierarchical or many-to-many.