Jimma University

Jimma Institute of Technology

Faculty of Computing and Informatics (FCI)
Department Of Computer Science, Tutorial on Data Structures and Algorithm
Analysis for Exit Exam Preparation, Prepared by Bekan Kitaw (M.Sc), June 06, 2025

This tutorial is designed to prepare students for their exit exam in Data Structures and Algorithm
Analysis (DSAAA). It provides a thorough understanding of key data structures like stacks, queues,
linked lists, trees, and graphs, as well as algorithm analysis techniques, including asymptotic
notations, time and space complexity, and algorithm design paradigms such as greedy, dynamic
programming, and backtracking. Each section includes detailed notes, practical examples, and
practice questions.
Understanding Data Structures
What is a Queue?
A queue is a linear data structure that operates on the First In, First Out (FIFO) principle, where
elements are added at the rear and removed from the front. This mimics real-world scenarios
like a line of customers at a checkout counter. Queues are used in scheduling processes, handling
requests in web servers, and managing tasks in operating systems.
- Queues can be implemented using arrays or linked lists. Array-based queues have a fixed
size, while linked-list-based queues are dynamic.
- Variants include circular queues (to reuse empty spaces) and priority queues (where
elements have priorities).
- Common applications include printer job scheduling and breadth-first search in graphs.
- Time complexity: Enqueue and dequeue operations are typically O(1).
Practice Question:
1. Which data structure allows insertion at one end and removal from the opposite end?
a) Stack c) Array
b) Queue d) Tree
Answer: b) Queue. Queues add elements at the rear and remove them from the front, FIFO.
2. What is the main advantage of using a circular queue over a regular linear queue?
a) It allows elements to be removed from both ends
b) It simplifies the enqueue and dequeue operations
c) It prevents overflow by reusing freed space
d) It prioritizes elements based on value
Answer: c) It prevents overflow by reusing freed space

What is a Stack?
A stack is a linear data structure following the Last In, First Out (LIFO) principle, where
elements are added and removed from the same end, called the top. Think of a stack of books,
where you can only add or remove the topmost book. Stacks are used in function call
management, expression evaluation, and undo operations in software.
- Stacks can be implemented using arrays or linked lists, with O(1) time for push and pop
operations.
- Applications include parsing expressions (e.g., converting infix to postfix) and
backtracking algorithms.
- Stacks are memory-efficient for problems requiring reverse-order processing.
- A stack overflow occurs when too many elements are pushed onto a fixed-size stack.
Practice Question:
3. Which operation is NOT typically used with a stack?
a) Add to top c) Add to rear
b) Remove from top d) View top element
Answer: c) Add to rear. Stacks use push (add to top) and pop (remove from top), not enqueue,
which is queue-specific.
4. If elements are added to a stack in the order A, B, C, what principle governs their removal?
a) First In, First Out c) Random order
b) Last In, First Out d) Alphabetical order
Answer: b) Last In, First Out. Stacks remove the most recently added element first (LIFO).
5. Which real-world scenario best represents a stack?
a) A line at a ticket counter c) A queue at a bank
b) A pile of dishes in a kitchen d) A sorted list of books
Answer: b) A pile of dishes. You can only add or remove dishes from the top, mimicking a stack.

Singly Linked Lists

A singly linked list consists of nodes, each containing data and a pointer to the next node. The last
node points to null, marking the end of the list. Linked lists are dynamic, allowing easy insertion
and deletion compared to arrays.
- Linked lists are ideal for applications where the size of the list changes frequently, like task
managers.
- Operations include insertion (O(1) at the head, O(n) at the end), deletion, and traversal
 (O(n)).
- Variants include doubly linked lists (with pointers to both next and previous nodes) and
circular linked lists.
- Memory overhead comes from storing pointers, unlike arrays.
Practice Question:
6. In a singly linked list, what does the final node point to?
a) First node c) Null
b) Previous node d) Itself
Answer: c) Null. The last node’s pointer is null, indicating the list’s end.
7. What is one main advantage of using a singly linked list over an array?
a) Faster access to middle elements
b) Dynamic size adjustment without reallocating memory
c) Lower memory usage due to no pointers
d) Easier to sort using built-in functions
Answer: b) Dynamic size adjustment without reallocating memory. Linked lists can
grow/shrink as needed, making them ideal for situations where the number of elements frequently
changes.

Comparing Data Structures

Data structures like arrays, queues, linked lists, and trees serve distinct purposes. Arrays provide
fast access via indices, queues manage FIFO operations, linked lists offer flexibility, and trees
organize data hierarchically for efficient searching and sorting.
- Arrays are static, with fixed sizes, while linked lists are dynamic.
- Queues and stacks are abstract data types, often implemented using arrays or linked lists.
- Trees are used in databases, file systems, and decision-making algorithms.
- Choosing the right data structure depends on the problem’s requirements, such as access
speed or insertion frequency.
Practice Question:
8. Which data structure stands out different from the other?
a) Array c) Tree
b) Queue d) Linked List
Answer: c) Tree. Trees have a hierarchical structure, unlike the linear nature of the others.
Graph Traversal: Breadth-First Search
Breadth-First Search (BFS) explores a graph level by level, visiting all neighbors of a node before
moving deeper. It uses a queue to track nodes to visit, making it ideal for finding the shortest path
in unweighted graphs.
- BFS starts at a root node, enqueues it, and dequeues nodes while enqueuing their unvisited
neighbors.
- Applications include GPS navigation, social network analysis, and puzzle-solving.
- Time complexity is O(V + E), where V is vertices and E is edges.
- Space complexity is O(V) due to the queue and visited set.
Practice Question:
9. Which data structure supports BFS in a graph?
a) Queue c) Array
b) Stack d) Linked List
Answer: a) Queue. BFS uses a queue to process nodes in FIFO order.

Analyzing Data Structures and Algorithms

Stack Operations
Analyzing a stack involves tracking push (add to top) and pop (remove from top) operations.
Consider a sequence: add 5, add 15, remove, add 25, remove, remove. Tracing it:
- Add 5: Stack = [5]
- Add 15: Stack = [5, 15]
- Remove: Stack = [5]
- Add 25: Stack = [5, 25]
- Remove: Stack = [5]
- Remove: Stack = [ ]
In general,
- Stack operations are O(1), making them efficient for LIFO-based tasks.
- Stacks are critical in recursive algorithms, where the call stack manages function calls.
- Example applications include browser history and expression parsing.
Practice Question:
10. After the sequence add 5, add 15, remove, add 25, remove, remove, what is the stack’s state?
a) [5] c) [5, 25]
b) [15, 25] d) Empty
Answer: d) Empty. All elements are popped by the end.
Infix to Postfix Conversion
An infix expression (e.g., X + Y * (Z + W)) is converted to postfix using a stack to manage
operator precedence. For X + Y * (Z + W):
- Process symbols, respecting parentheses and precedence (* before +).
- Postfix equivalent: X Y Z W + * +
In general,
- Postfix eliminates parentheses, simplifying evaluation.
- Steps: Use a stack for operators, output operands immediately, pop operators based on
precedence.
- Time complexity is O(n), where n is the expression length.
- Used in compilers and calculators.
Practice Question:
11. Convert the infix expression A * (B + C) / D - E to postfix.
a) A B C + * D / E -
b) A B + C * D / - E
c) A B C + D * / E -
d) A * B C + / D - E
Answer: a) A B C + * D / E - This follows correct operator precedence.

Asymptotic Notation: Big-O

Asymptotic notation describes algorithm performance as input size grows. Big-O, (O) provides the
upper bound, representing the worst-case running time.
- Big-O ignores constants and lower-order terms (e.g., O(3n² + 2n) simplifies to O(n²)).
- Common complexities: O(1) (constant), O(log n) (logarithmic), O(n) (linear), O(n²)
(quadratic).
- Used to compare algorithms, e.g., O(n log n) sorting vs. O(n²) sorting.
- Big-O is part of a family with Big-Omega (lower bound) and Theta (tight bound).
Practice Question:
12. Which notation represents the worst-case running time of an algorithm?
a) Big-Omega c) Big-O
b) Theta d) Little-o
Answer: c) Big-O. It defines the upper bound.
Applying Data Structures and Algorithms
Bubble Sort
Bubble Sort sorts an array by repeatedly swapping adjacent elements if they are in the wrong order.
For [7, 4, 9, 2, 1], the first pass:
- Compare 7, 4: Swap → [4, 7, 9, 2, 1]
- Compare 7, 9: No swap → [4, 7, 9, 2, 1]
- Compare 9, 2: Swap → [4, 7, 2, 9, 1]
- Compare 9, 1: Swap → [4, 7, 2, 1, 9]
In general,
- Time complexity: O(n²) in worst and average cases, O(n) in best case (sorted array).
- Space complexity: O(1) as it sorts in place.
- Simple but inefficient for large datasets compared to Quick Sort or Merge Sort.
- Useful for educational purposes or small lists.
Practice Question:
13. After one pass of Bubble Sort on [7, 4, 9, 2, 1], what is the array?
a) [4, 7, 2, 1, 9] c) [4, 2, 1, 7, 9]
b) [4, 7, 2, 9, 1] d) [1, 2, 4, 7, 9]
Answer: a) [4, 7, 2, 1, 9]. The largest element (9) moves to the end.

Linear Search
Linear Search checks each element in a list until the target is found. For [15, 25, 35, 45, 55],
searching for 45:
- Check 15 (1st)
- Check 25 (2nd)
- Check 35 (3rd)
- Check 45 (4th, found)
In general,
- Time complexity: O(n) in worst and average cases.
- No preprocessing required, unlike Binary Search.
- Suitable for unsorted or small lists.
- Space complexity: O(1).
Practice Question:
14. How many comparisons are needed to find 45 in [15, 25, 35, 45, 55] using Linear Search?
a) 1 b) 2 c) 3 d) 4
Answer: d) 4. Four elements are checked to find 45.
Worst-Case Analysis
Worst-case analysis evaluates the maximum time an algorithm takes for any input of size n,
ensuring performance guarantees under the toughest conditions.
In general,
- Worst-case is critical for real-time systems where delays are unacceptable.
- Example: Linear Search’s worst case is O(n) when the element is at the end or absent.
- Contrasts with average-case (expected performance) and best-case (optimal scenario).
- Helps in choosing algorithms for critical applications.
Practice Question:
15. What does worst-case analysis focus on?
a) Minimum time for any input
b) Average time for random inputs
c) Maximum time for any input
d) Time for smallest input
Answer: c) Maximum time for any input. It considers the worst scenario.

Binary Search
Binary Search requires a sorted list and halves the search space each step, achieving O(log n) time
complexity.
- Steps: Compare the target with the middle element, then search the left or right half.
- Requires preprocessing (sorting) if the list is unsorted.
- Applications: Searching in databases, lookup tables.
- Space complexity: O(1) for iterative, O(log n) for recursive due to call stack.
Practice Question:
16. Which search algorithm needs a sorted list to function?
a) Linear Search c) Breadth-First Search
b) Binary Search d) Depth-First Search
Answer: b) Binary Search. It depends on sorted data to halve the search space.

Asymptotic Analysis
Asymptotic analysis studies an algorithm’s performance as input size grows, focusing on time and
space complexity rather than exact metrics.
- Ignores constants and hardware-specific factors for portability.
- Helps predict scalability for large inputs.
 - Example: Bubble Sort (O(n²)) vs. Merge Sort (O(n log n)).
- Used in algorithm design to optimize performance.
Practice Question:

17. Why are constant factors usually ignored in asymptotic analysis?

a) Because they depend on the input data

b) Because they vary based on programming language
c) Because they don't affect performance for small inputs
d) Because they don’t significantly impact growth rate as input size increases

Answer: d) Because they don’t significantly impact growth rate as input size increases.
Asymptotic analysis focuses on long-term behavior, so constants and lower-order terms are
considered negligible.
18. What does asymptotic analysis evaluate?
a) Computer speed c) Data structure size
b) Algorithm performance as input d) Code length
grows
Answer: b) Algorithm performance as input grows. It focuses on scalability.

Binary Trees
A binary tree is a hierarchical structure where each node has at most two children (left and right),
used in searching, sorting, and hierarchical data representation.
- Types: Full (all nodes have 0 or 2 children), complete (all levels filled except possibly the
last).
- Applications: Binary Search Trees, expression trees, heap data structures.
- Traversal methods: Inorder, Preorder, Postorder, Level-order.
- Time complexity for operations like insertion or search in a balanced tree is O(log n).
Practice Question:
19. What characterizes a binary tree?
a) At most two children per node c) Circular node arrangement
b) Exactly two children per node d) Random node connections
Answer: a) At most two children per node. This defines a binary tree.
20. In a binary tree, how many children can a single node have at most?
a) One c) Three
b) Two d) Unlimited

Answer: b) Two. A binary tree limits each node to a maximum of two children—commonly re-
ferred to as the left and right child.

Evaluating Data Structures and Algorithms

Tree Traversals
Preorder traversal visits the root, then the left subtree, then the right subtree, useful for copying
trees or evaluating expressions.
- Other traversals: Inorder (left, root, right) for sorted output in BSTs, Postorder (left, right,
root) for deletion.
- Time complexity: O(n) for all traversals, where n is the number of nodes.
- Space complexity: O(h) for recursive (h is tree height), O(n) for iterative with a stack/queue.
- Applications: Expression evaluation, tree serialization.
Practice Question:
21. Which traversal processes the root before its subtrees?
a) Inorder c) Postorder
b) Preorder d) Level-order
Answer: b) Preorder. It visits root, left, right.

Directed Graphs
A directed graph has edges with direction, representing one-way relationships, like a social media
follow graph.
- Contrasts with undirected graphs, where edges are bidirectional.
- Applications: Network routing, dependency graphs, task scheduling.
- Represented using adjacency lists or matrices.
- Algorithms like BFS and DFS apply to directed graphs with modifications.
Practice Question:
22. Which feature distinguishes a directed graph from an undirected graph?
a) Nodes are connected randomly
b) Edges have a specific direction from one node to another
c) All nodes are connected to every other node
d) It always forms a tree structure
Answer: b) Edges have a specific direction from one node to another. Directed graphs have
edges with directions indicating one-way relationships.

Divide-and-Conquer Sorting
Quick Sort uses a divide-and-conquer approach, partitioning the array around a pivot and
recursively sorting subarrays.
- Time complexity: O(n log n) average, O(n²) worst case (e.g., sorted array with poor pivot).
- Space complexity: O(log n) for recursive calls.
- Other divide-and-conquer algorithms: Merge Sort, Binary Search.
- Efficient for large datasets compared to Bubble or Insertion Sort.

Practice Question:
23. What is the average-case time complexity of Quick Sort?
a) O(n²) c) O(log n)
b) O(n log n) d) O(n)
Answer: b) O(n log n). Quick Sort typically performs in O(n log n) time on average by dividing
the array and sorting subarrays recursively.
24. Which sorting algorithm employs divide-and-conquer?
a) Bubble Sort c) Insertion Sort
b) Quick Sort d) Selection Sort
Answer: b) Quick Sort. It divides the array into partitions.

Priority Queue
A priority queue dequeues elements based on priority, ideal for scenarios like a hospital
emergency room where critical patients are treated first.
- Implemented using heaps (binary heap: O(log n) for insert/dequeue).
- Applications: Task scheduling, Dijkstra’s algorithm, Huffman coding.
- Contrasts with regular queues (FIFO) and stacks (LIFO).
- Space complexity: O(n) for storing n elements.
Practice Question:
25. Which data structure allows elements with higher priority to be processed before others, regard-
less of their arrival order?
a) Stack c) Priority Queue
b) Regular Queue d) Linked List

Answer: c) Priority Queue. It prioritizes based on severity.

Algorithm Properties
Finiteness ensures an algorithm terminates after a finite number of steps, a hallmark of a well-
defined algorithm.
- Other properties: Definiteness (clear instructions), Effectiveness (feasible steps),
Input/Output (defined inputs and outputs).
- Finiteness prevents infinite loops, critical for reliability.
- Example: A sorting algorithm must eventually produce a sorted list.
- Violations lead to non-algorithms (e.g., infinite recursion without base case).
Practice Question:
26. Which property guarantees an algorithm will stop?
a) Finiteness c) Input
b) Definiteness d) Output
Answer: a) Finiteness. It ensures termination.

Complete Algorithms
A complete algorithm guarantees finding a solution if one exists, unlike incomplete algorithms that
may miss solutions.
- Completeness is crucial in search problems (e.g., BFS is complete for finite graphs).
- Contrasts with optimality (finding the best solution).
- Example: A chess algorithm that explores all moves to find a checkmate.
- Trade-off: Completeness may increase time complexity.
Practice Question:
27. What characterizes a complete algorithm?
a) May miss solutions c) Always finds the best solution
b) Finds a solution if one exists d) Runs fastest
Answer: b) Finds a solution if one exists. This defines completeness.

Advanced Algorithm Analysis

Purpose of Asymptotic Notations
Asymptotic notations compare algorithm efficiency as input size grows, abstracting away
hardware-specific details.
- Includes Big-O (upper bound), Big-Omega (lower bound), Theta (tight bound).
- Enables algorithm comparison (e.g., O(n) vs. O(n²)).
- Used in both time and space complexity analysis.
- Practical for predicting performance on large datasets.
 Practice Question:
28. What is the main role of asymptotic notations?
a) Calculate exact run time c) Measure memory usage
b) Compare efficiency for large inputs d) Debug code
Answer: b) Compare efficiency for large inputs.

Solving Recurrence Relations

The recursion tree method visualizes a recurrence relation as a tree, summing costs at each level
to estimate complexity.
Practice Question:
29. Which method visualizes a recurrence as a tree?
a) Iteration method c) Recursion tree method
b) Substitution method d) Master method
Answer: c) Recursion tree method. It builds a tree to analyze costs.

Time Complexity of Nested Loops

Consider:
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int j = 0; j < n; j++) {
count++;
}
}
}
The outer loop runs n times, inner loop n times per iteration, yielding n * n * n = n3 iterations, so
O(n3).
- Nested loops often lead to polynomial complexity (e.g., O(n²) for two loops).
- Analyze by counting iterations and operations per iteration.
- Example: Matrix multiplication is O(n³) with three nested loops.
- Optimization may reduce complexity (e.g., using Divide-and-Conquer).
Practice Question:
30. What is the time complexity of a double nested loop with n iterations each?
a) O(n) c) O(n²)
b) O(n log n) d) O(2n)
Answer: c) O(n²). The loops result in quadratic complexity.

Greedy Approach
The greedy approach makes locally optimal choices at each step, aiming for a global optimum, as
in Kruskal’s algorithm.
- Not always globally optimal (e.g., may fail in some knapsack problems).
- Time complexity depends on the problem (e.g., O(E log V) for Kruskal’s).
- Applications: Minimum spanning trees, Huffman coding.
- Contrasts with exhaustive search methods like backtracking.
Practice Question:
31. What strategy does the greedy approach use?
a) Break into subproblems c) Explore all solutions
b) Choose locally optimal steps d) Store subproblem results
Answer: b) Choose locally optimal steps.
Practice Question:
32. How does the greedy method aim to optimize solutions?
a) Exhaustive search c) Locally optimal choices
b) Subproblem division d) Single subproblem solution
Answer: c) Locally optimal choices. This is the greedy strategy.

Big Omega Notation

Big Omega (Ω) denotes the lower bound of an algorithm’s running time, describing the best-case
scenario.
- Example: Ω(n log n) for comparison-based sorting algorithms.
- Used to guarantee minimum performance.
- Complements Big-O (upper bound) and Theta (tight bound).
- Practical for understanding best-case efficiency.
Practice Question:
33. What does Big Omega represent?
a) Upper bound c) Average case
b) Lower bound d) Exact run time
Answer: b) Lower bound. It describes the minimum time.
Goal of Algorithm Analysis
Algorithm analysis determines the resources (time and space) required, enabling efficiency
comparisons.
- Focuses on scalability, not exact run times.
- Includes time (execution duration) and space (memory usage) analysis.
- Critical for choosing algorithms in resource-constrained environments.
- Example: Choosing Merge Sort over Bubble Sort for large datasets.
Practice Question:
34. What is the main objective of algorithm analysis?
a) Code in multiple languages c) Resource requirement estimation
b) Error testing d) Code debugging
Answer: c) Resource requirement estimation.

Time vs. Space Complexity

Time complexity measures execution time, while space complexity measures memory usage,
both critical for algorithm evaluation.
- Time complexity examples: O(n) for Linear Search, O(log n) for Binary Search.
- Space complexity includes auxiliary space (e.g., temporary arrays) and input space.
- Trade-offs: Recursive algorithms may save code complexity but increase space (call stack).
- Example: Merge Sort (O(n) space) vs. Quick Sort (O(log n) space).
Practice Question:
35. How do time and space complexity differ?
a) Time depends on input, space does not
b) Time measures memory, space measures time
c) Time measures execution, space measures memory
d) Time uses asymptotic notation, space does not
Answer: c) Time measures execution, space measures memory.

Dynamic Programming
Dynamic Programming (DP) solves problems by storing subproblem results to avoid
recomputation, using top-down (memoization) or bottom-up (tabulation) approaches.
- Example: Fibonacci sequence (O(n) with DP vs. O(2^n) recursively).
- Applications: Knapsack problem, shortest paths (Floyd-Warshall).
- Requires overlapping subproblems and optimal substructure.
- Space-time trade-off: DP uses extra memory to save time.
 Practice Question:
36. What is a key feature of Dynamic Programming?
a) Independent subproblems c) Uses subproblem results
b) Top-down only d) Finds local optima
Answer: c) Uses subproblem results. DP relies on memoization or tabulation.

Backtracking
Backtracking explores all possible solutions, backtracking when a path fails, as in solving Sudoku
or N-Queens.
- Time complexity often exponential (e.g., O(n!) for permutations).
- Uses a state space tree to represent all possibilities.
- Optimization: Pruning invalid branches (e.g., in constraint satisfaction problems).
- Contrasts with greedy (local optima) and DP (stored subproblems).
Practice Question:
37. What is the core idea of backtracking?
a) Divide into independent subproblems
b) Locally optimal choices
c) Explore all possibilities
d) Store subproblem results
Answer: c) Explore all possibilities. Backtracking tries every path.
38. Which technique is used to find all valid solutions by exploring all possibilities?
a) Dynamic Programming c) Backtracking
b) Greedy Method d) Divide and Conquer
Answer: c) Backtracking. It exhaustively searches for solutions.

Binary Search Efficiency

Binary Search is efficient because it halves the search space each step, yielding O(log n) time
complexity.
- Requires sorted data, unlike Linear Search (O(n)).
- Iterative version is more space-efficient than recursive.
- Applications: Searching in sorted arrays, BST operations.
- Limitations: Ineffective for unsorted or dynamic data.
Practice Question:
39. Why is Binary Search efficient?
a) Checks every element b) Reduces search space by half
 c) Works only on small lists d) Uses extra memory
Answer: b) Reduces search space by half. This is its key efficiency.

Job Sequencing with Deadlines

Job Sequencing with Deadlines maximizes profit by selecting jobs completable within their
deadlines, typically using a greedy approach.
- Steps: Sort jobs by profit, select jobs that fit within deadlines.
- Time complexity: O(n log n) for sorting, O(n) for selection.
- Applications: Task scheduling in operating systems.
- Assumes jobs have deadlines and profits.
Practice Question:
40. What does Job Sequencing with Deadlines aim to achieve?
a) Minimize execution time c) Maximize profit within deadlines
b) Maximize completed jobs d) Sort by deadlines
Answer: c) Maximize profit within deadlines.

State Space Tree in Backtracking

A state space tree represents all possible states in a backtracking problem, allowing systematic
exploration of solutions.
- Each node is a partial solution, edges are decisions.
- Example: N-Queens problem uses a state space tree for queen placements.
- Pruning reduces the tree size by eliminating invalid paths.
- Time complexity depends on tree size (often exponential).
Practice Question:
41. What does a state space tree in backtracking represent?
a) Only optimal paths c) Only incorrect paths
b) All possible states d) A binary search tree
Answer: b) All possible states. It captures all configurations.

Feasible Solutions
A feasible solution satisfies all constraints in an optimization problem, though it may not be
optimal.
- Example: In knapsack, a feasible solution fits within weight limits.
- Contrasts with optimal solutions (best among feasible).
- Used in constraint satisfaction problems (e.g., scheduling).
 - Algorithms like backtracking find all feasible solutions.
Practice Question:
42. What is a feasible solution in optimization?
a) The best solution c) Easy to find
b) Satisfies all constraints d) Randomly generated
Answer: b) Satisfies all constraints. This defines feasibility.
Defining an Algorithm
An algorithm is a finite set of instructions to solve a problem. Example: “Input two numbers,
multiply them, output the result” is an algorithm due to its clear steps.
- Properties: Finiteness, definiteness, effectiveness, input/output.
- Example: Euclid’s algorithm for GCD.
- Simple instructions can form an algorithm if they solve a problem.
- Not language-specific; focus is on logic.
Practice Question:
43. Is the process “Receive two inputs, add them, and print the sum” considered an algorithm?
a) Yes, it follows a defined logical sequence
b) No, because it doesn’t use any variables
c) No, it's just a single operation
d) Yes, but only if it runs inside a computer

Answer: a) Yes, it’s a set of instructions. It meets algorithm criteria.

Choosing Algorithms for Large Datasets

For large inputs, choose algorithms with lower time complexity. O(n log n) (e.g., Merge Sort) is
faster than O(n³) (e.g., matrix multiplication) for large n.
- O(n log n) grows slowly, suitable for large datasets.
- O(n³) becomes impractical as n increases (e.g., 1 million³ operations).
- Consider space complexity and practical constraints (e.g., memory).
- Example: Quick Sort vs. Bubble Sort for sorting large lists.
Practice Question:
44. For large datasets, which is faster: O(n log n) or O(n³)?
a) O(n³), more complex c) Either, complexity irrelevant
b) O(n log n), grows slower d) O(n³), for small datasets
Answer: b) O(n log n), grows slower. It’s more efficient.
Brute-Force in Password Cracking
Brute-force tries every possible combination, as in password cracking, until the correct solution is
found.
- Time complexity: Exponential (e.g., O(c^n) for n characters, c choices).
- Guaranteed to find a solution but inefficient.
- Alternatives: Dictionary attacks, heuristic-based guessing.
- Used when other methods (e.g., cryptanalysis) fail.
Practice Question:
45. Which method tries all possible password combinations?
a) Using common passwords c) Analyzing character frequencies
b) Trying every combination d) Guessing based on user info
Answer: b) Trying every combination. This is brute-force.

Analyzing a Recursive Function

Assuming a function:
int count(int n) {
if (n <= 0) return 0;
return n + count(n - 1);
}
For count(3):
- count(3) = 3 + count(2)
- count(2) = 2 + count(1)
- count(1) = 1 + count(0)
- count(0) = 0
- Total: 3 + 2 + 1 + 0 = 6
In general,
- Recursive functions break problems into smaller instances.
- Time complexity: O(n) for count(n) due to n recursive calls.
- Space complexity: O(n) for call stack.
- Base case (n <= 0) ensures finiteness.
Practice Question:
46. What is the output of count(3) for the above function?
a) 0 b) 3 c) 6 d) 9
Answer: c) 6. It sums 1 to 3.
47. What is the output of this C++ queue-based code?
queue<int> q;
q.push(10);
q.push(20);
q.pop();
cout << q.front();
a) 10 c) 0
b) 20 d) Error

Answer: b) 20. First 10 is inserted and removed using pop(). Then front() is 20.

49. What is the output?

int x = 8;
cout << (x & (x - 1));

a) 8 c) 1
b) 0 d) 7

Answer: b) 0. x & (x - 1) removes the lowest set bit. For 8 (1000), result is 0.

50. What is the time complexity of this code?

for (int i = 0; i < n; i++) {
cout << "A";
}
for (int j = 0; j < n; j++) {
cout << "B";
}
a) O(n) c) O(n²)
b) O(2n) d) O(1)

Answer: a) O(n). Two separate linear loops → O(n + n) = O(n)

Every hour of study brings you closer to success.