ALGORITHMS — Computer Operator Exam Preparation Guide
ALGORITHMS
A Complete Study Guide for Computer Operator Examinations
Topics Covered:
• Definition & Properties of Algorithms
• Types of Algorithms
• Algorithm Complexity & Big-O Notation
• Sorting Algorithms
• Searching Algorithms
• Recursion & Divide and Conquer
• Greedy Algorithms
• Dynamic Programming
• Graph Algorithms
• Flowcharts & Pseudocode
• Practice Questions & MCQs
Computer Operator Exam Guide Page 1
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 1: Introduction to Algorithms
1.1 What is an Algorithm?
An algorithm is a well-defined, finite sequence of instructions or steps used to solve a specific
problem or perform a computation. The word "algorithm" comes from the name of Persian
mathematician Muhammad ibn Musa al-Khwarizmi.
Key Definition
Algorithm: A finite, ordered set of unambiguous, executable steps that takes some input,
processes it, and produces a desired output within a finite amount of time.
1.2 Properties of a Good Algorithm
A good algorithm must have the following five essential properties:
• Input: An algorithm must have zero or more well-defined inputs from an external
source.
• Output: An algorithm must produce at least one output that is the solution to the
problem.
• Definiteness: Every step of the algorithm must be clear, precise, and unambiguous.
• Finiteness: The algorithm must terminate after a finite number of steps (it must not
run forever).
• Effectiveness: Each step must be basic enough to be carried out, in principle, by a
person using pencil and paper.
1.3 Why Study Algorithms?
Understanding algorithms is fundamental to computer science and programming because:
• Algorithms are the backbone of all software and computing solutions.
• They help us solve problems efficiently in terms of time and memory.
• Analyzing algorithms helps select the best approach for a given problem.
• Algorithm knowledge is tested in almost every computer operator exam.
• They improve logical thinking and problem-solving skills.
1.4 Algorithm vs Program vs Flowchart
Computer Operator Exam Guide Page 2
ALGORITHMS — Computer Operator Exam Preparation Guide
Feature Algorithm Program Flowchart
Nature Step-by-step Code in a Graphical
logic language representation
Language English / C, Python, Java, Symbols &
pseudocode etc. arrows
Execution Cannot be run Can be executed Cannot be
directly on computer executed
Purpose Problem-solving Implementation Visual
plan understanding
Audience Humans / Computers / Humans /
developers developers learners
Computer Operator Exam Guide Page 3
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 2: Algorithm Complexity & Big-O Notation
2.1 What is Algorithm Complexity?
Algorithm complexity measures the amount of resources (time and space) required by an algorithm
as the input size grows. There are two main types:
• Time Complexity: The amount of time an algorithm takes to complete as a function of input
size n.
• Space Complexity: The amount of memory an algorithm uses as a function of input size n.
2.2 Big-O Notation
Big-O notation is a mathematical notation used to describe the upper bound (worst-case) of an
algorithm's growth rate. It expresses how the runtime or space requirements scale with the input
size.
Notation Name Example Description
O(1) Constant Array access by Runtime does not change
index with input size
O(log n) Logarithmic Binary Search Runtime grows
logarithmically
O(n) Linear Linear Search Runtime grows
proportionally with n
O(n log n) Linearithmic Merge Sort, Heap Slightly worse than linear
Sort
O(n²) Quadratic Bubble Sort, Runtime grows as square
Insertion Sort of n
O(n³) Cubic Matrix multiplication Three nested loops
(naive)
O(2ⁿ) Exponential Fibonacci (recursive) Doubles with each addition
to n
O(n!) Factorial Brute-force Extremely slow; impractical
permutations for large n
2.3 Best, Average, and Worst Case
For any algorithm, we can analyze three scenarios:
Computer Operator Exam Guide Page 4
ALGORITHMS — Computer Operator Exam Preparation Guide
• Best Case (Ω - Omega): The minimum time required — when the algorithm gets lucky (e.g.,
target is first element in search).
• Average Case (Θ - Theta): The expected time for a random input — the most realistic
measure.
• Worst Case (O - Big-O): The maximum time required — the scenario that takes the longest.
Exam Tip
In examinations, when asked about complexity without specifying case, always assume WORST
CASE (Big-O).
Example: Linear Search has O(1) best case and O(n) worst case. The standard answer is O(n).
Computer Operator Exam Guide Page 5
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 3: Sorting Algorithms
Sorting is the process of arranging elements in a specific order (ascending or descending). It is one
of the most fundamental algorithmic problems in computer science.
3.1 Bubble Sort
Bubble Sort is the simplest sorting algorithm. It repeatedly compares adjacent elements and swaps
them if they are in the wrong order, causing larger elements to 'bubble' to the end.
• Time Complexity: O(n²) — Worst and Average Case
• Space Complexity: O(1) — In-place algorithm
• Stable Sort: Yes — does not change the relative order of equal elements
• Best for: Small datasets or nearly sorted data (best case O(n))
Pseudocode — Bubble Sort
FOR i = 0 to n-1:
FOR j = 0 to n-i-2:
IF array[j] > array[j+1]:
SWAP array[j] and array[j+1]
END IF
END FOR
END FOR
3.2 Selection Sort
Selection Sort divides the array into a sorted and unsorted part. It repeatedly finds the minimum
element from the unsorted portion and places it at the beginning.
• Time Complexity: O(n²) — All cases
• Space Complexity: O(1)
• Stable Sort: No
• Advantage: Minimum number of swaps — at most n-1 swaps
Pseudocode — Selection Sort
FOR i = 0 to n-1:
min_index = i
FOR j = i+1 to n-1:
Computer Operator Exam Guide Page 6
ALGORITHMS — Computer Operator Exam Preparation Guide
IF array[j] < array[min_index]:
min_index = j
SWAP array[i] and array[min_index]
END FOR
3.3 Insertion Sort
Insertion Sort builds the sorted array one item at a time by taking elements from the unsorted part
and inserting them at the correct position in the sorted part.
• Time Complexity: O(n²) — Worst; O(n) — Best (already sorted)
• Space Complexity: O(1)
• Stable Sort: Yes
• Best for: Small datasets and nearly sorted arrays
3.4 Merge Sort
Merge Sort is a divide-and-conquer algorithm. It divides the array into two halves, recursively sorts
each half, then merges the two sorted halves.
• Time Complexity: O(n log n) — All cases
• Space Complexity: O(n) — Requires auxiliary space
• Stable Sort: Yes
• Best for: Large datasets, linked lists, external sorting
3.5 Quick Sort
Quick Sort selects a 'pivot' element and partitions the array into two sub-arrays — elements less
than the pivot and elements greater than the pivot — then recursively sorts each sub-array.
• Time Complexity: O(n log n) Average; O(n²) Worst
• Space Complexity: O(log n) — Stack space for recursion
• Stable Sort: No
• Best for: General-purpose sorting; fastest in practice on average
3.6 Heap Sort
Heap Sort uses a binary heap data structure. It first builds a max-heap from the input and then
repeatedly extracts the maximum element to produce a sorted array.
• Time Complexity: O(n log n) — All cases
• Space Complexity: O(1)
• Stable Sort: No
• Best for: When guaranteed O(n log n) and O(1) space is needed
Computer Operator Exam Guide Page 7
ALGORITHMS — Computer Operator Exam Preparation Guide
3.7 Sorting Algorithm Comparison
Algorithm Best Average Worst Space Stable
Bubble Sort O(n) O(n²) O(n²) O(1) Yes
Selection Sort O(n²) O(n²) O(n²) O(1) No
Insertion Sort O(n) O(n²) O(n²) O(1) Yes
Merge Sort O(n log n) O(n log n) O(n log n) O(n) Yes
Quick Sort O(n log n) O(n log n) O(n²) O(log n) No
Heap Sort O(n log n) O(n log n) O(n log n) O(1) No
Computer Operator Exam Guide Page 8
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 4: Searching Algorithms
Searching is the process of finding a specific element (called the search key or target) within a
collection of data.
4.1 Linear Search (Sequential Search)
Linear Search checks every element one by one from the beginning until the target is found or the
list ends.
• Time Complexity: O(n) — Worst Case; O(1) — Best Case
• Works on: Sorted and unsorted arrays
• No preprocessing required
Pseudocode — Linear Search
FOR i = 0 to n-1:
IF array[i] == target:
RETURN i (element found at index i)
END IF
END FOR
RETURN -1 (element not found)
4.2 Binary Search
Binary Search works on a sorted array. It repeatedly divides the search interval in half. If the target
is less than the middle element, search the left half; otherwise, search the right half.
• Time Complexity: O(log n) — Worst Case; O(1) — Best Case
• Works on: Sorted arrays ONLY
• Requires preprocessing (sorting) if array is unsorted
• Extremely efficient for large datasets
Pseudocode — Binary Search
low = 0, high = n-1
WHILE low <= high:
mid = (low + high) / 2
IF array[mid] == target:
RETURN mid
ELSE IF array[mid] < target:
Computer Operator Exam Guide Page 9
ALGORITHMS — Computer Operator Exam Preparation Guide
low = mid + 1
ELSE:
high = mid - 1
RETURN -1 (not found)
4.3 Linear Search vs Binary Search
Feature Linear Search Binary Search
Time Complexity O(n) O(log n)
Array Requirement Sorted or Unsorted Must be Sorted
Efficiency Less efficient More efficient
Implementation Simple More complex
Best Case O(1) O(1)
Applications Small/unsorted data Large sorted data
Computer Operator Exam Guide Page 10
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 5: Recursion & Divide and Conquer
5.1 What is Recursion?
Recursion is a technique where a function calls itself directly or indirectly to solve a problem. A
recursive solution breaks a problem into smaller subproblems of the same type until it reaches a
simple base case.
Two Essential Parts of Recursion
1. Base Case: The condition that stops the recursion (prevents infinite loop).
2. Recursive Case: The part where the function calls itself with a smaller input.
5.2 Factorial Example
Pseudocode — Factorial (Recursive)
FUNCTION factorial(n):
IF n == 0 OR n == 1: // Base case
RETURN 1
ELSE:
RETURN n * factorial(n - 1) // Recursive call
Example: factorial(5) = 5 * 4 * 3 * 2 * 1 = 120
5.3 Fibonacci Sequence
The Fibonacci sequence is: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... where each number is the sum of the
previous two.
Pseudocode — Fibonacci (Recursive)
FUNCTION fibonacci(n):
IF n == 0: RETURN 0 // Base case 1
IF n == 1: RETURN 1 // Base case 2
RETURN fibonacci(n-1) + fibonacci(n-2) // Recursive
Note: Naive recursive Fibonacci has O(2^n) time complexity — very inefficient!
Computer Operator Exam Guide Page 11
ALGORITHMS — Computer Operator Exam Preparation Guide
5.4 Divide and Conquer Strategy
Divide and Conquer is a powerful algorithmic paradigm with three phases:
• Divide: Break the problem into smaller subproblems of the same type.
• Conquer: Solve each subproblem recursively (or directly if small enough).
• Combine: Merge the solutions of subproblems to get the final answer.
Algorithms using Divide and Conquer: Merge Sort, Quick Sort, Binary Search, Strassen's Matrix
Multiplication, Fast Fourier Transform (FFT).
Computer Operator Exam Guide Page 12
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 6: Greedy Algorithms & Dynamic Programming
6.1 Greedy Algorithms
A Greedy Algorithm makes the locally optimal choice at each step, hoping the global optimum will
be achieved. It never reconsiders a choice once made.
Greedy Algorithm Characteristics
• Makes the best available choice at each step
• Does not backtrack or reconsider previous decisions
• Simple and efficient to implement
• Does NOT always give the globally optimal solution
• Works correctly for some problems (Fractional Knapsack, Dijkstra's) but not others (0/1
Knapsack)
Common Greedy Algorithm Problems:
• Fractional Knapsack Problem
• Activity Selection / Job Scheduling
• Huffman Coding (Data Compression)
• Minimum Spanning Tree — Prim's and Kruskal's Algorithms
• Dijkstra's Shortest Path Algorithm
6.2 Dynamic Programming (DP)
Dynamic Programming solves complex problems by breaking them into overlapping subproblems,
solving each subproblem only once, and storing results to avoid redundant computation
(memoization or tabulation).
Two DP Approaches
1. Top-Down (Memoization): Use recursion + store results of solved subproblems in a table.
2. Bottom-Up (Tabulation): Build the solution iteratively from the smallest subproblems up.
DP applies when a problem has:
• Optimal Substructure: The optimal solution contains optimal solutions to subproblems.
• Overlapping Subproblems: The same subproblems are solved multiple times.
Classic DP Problems:
Computer Operator Exam Guide Page 13
ALGORITHMS — Computer Operator Exam Preparation Guide
• Fibonacci Number (DP makes it O(n) instead of O(2^n))
• 0/1 Knapsack Problem
• Longest Common Subsequence (LCS)
• Longest Increasing Subsequence (LIS)
• Matrix Chain Multiplication
• Coin Change Problem
6.3 Greedy vs Dynamic Programming
Feature Greedy Algorithm Dynamic Programming
Decision Making Local optimal choice Globally optimal via subproblems
Reconsideration No backtracking All subproblems explored
Efficiency Generally faster O(n log n) Slower but more thorough
Accuracy Not always optimal Always finds optimal solution
Memory Low (O(1) often) Higher (stores subproblem results)
Example Fractional Knapsack 0/1 Knapsack
Computer Operator Exam Guide Page 14
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 7: Graph Algorithms
7.1 Graph Basics
A graph G = (V, E) consists of a set of Vertices (V) and a set of Edges (E) connecting pairs of
vertices. Graphs model networks, maps, social connections, and many real-world problems.
• Directed Graph (Digraph): Edges have a direction (one-way connections).
• Undirected Graph: Edges have no direction (two-way connections).
• Weighted Graph: Each edge has a numerical weight/cost.
• Unweighted Graph: All edges have equal weight.
• Connected Graph: Every vertex is reachable from every other vertex.
7.2 Graph Traversal
Breadth-First Search (BFS)
BFS explores all neighbors at the current depth level before moving deeper. It uses a Queue data
structure.
• Time Complexity: O(V + E)
• Uses: Shortest path in unweighted graphs, level-order traversal, connected components
• Data Structure Used: Queue (FIFO)
Depth-First Search (DFS)
DFS explores as far as possible along a branch before backtracking. It uses a Stack or recursion.
• Time Complexity: O(V + E)
• Uses: Topological sorting, detecting cycles, maze solving, strongly connected components
• Data Structure Used: Stack (or recursion)
7.3 BFS vs DFS Comparison
Feature BFS DFS
Data Structure Queue Stack / Recursion
Traversal Order Level by level Depth first
Memory More (wide graphs) Less (deep graphs)
Shortest Path Yes (unweighted) No guarantee
Computer Operator Exam Guide Page 15
ALGORITHMS — Computer Operator Exam Preparation Guide
Feature BFS DFS
Use Case Shortest path, web crawling Cycle detection, topological sort
Completeness Yes (finite graphs) Yes (finite graphs)
7.4 Shortest Path Algorithms
• Dijkstra's Algorithm: Finds shortest paths from a source to all vertices in a weighted graph
with non-negative weights. Time: O((V + E) log V).
• Bellman-Ford Algorithm: Handles negative weights. Detects negative cycles. Time: O(VE).
• Floyd-Warshall Algorithm: All-pairs shortest path. Time: O(V³). Uses DP approach.
7.5 Minimum Spanning Tree (MST)
A Minimum Spanning Tree connects all vertices with the minimum total edge weight (no cycles).
Used in network design, cluster analysis.
• Kruskal's Algorithm: Sorts all edges by weight, adds edges greedily using Union-Find. O(E
log E).
• Prim's Algorithm: Starts from a vertex and grows the MST by adding the minimum weight
edge. O(E log V).
Computer Operator Exam Guide Page 16
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 8: Flowcharts & Pseudocode
8.1 Flowchart Symbols
A flowchart is a graphical representation of an algorithm using standardized symbols. Every symbol
has a specific meaning:
Symbol Shape Symbol Name Purpose / Usage
Oval / Rounded Terminal (Start/End) Marks the beginning or end of the algorithm
Rectangle
Rectangle Process Box Represents a computation or action step
Diamond / Rhombus Decision Box Represents a Yes/No or True/False condition
Parallelogram Input / Output Represents reading input or displaying output
Arrow / Line Flow Line Shows the direction of execution flow
Circle Connector Connects different parts of the flowchart
Rectangle with bands Predefined Process Represents a subroutine or function call
8.2 Rules for Drawing Flowcharts
1. Every flowchart must have exactly ONE Start and ONE End terminal.
2. All decision boxes must have exactly TWO branches: YES and NO.
3. Flow lines must not cross each other; use connectors if necessary.
4. The flow direction is generally top to bottom and left to right.
5. Each symbol should contain only one function or decision.
6. Loops must be clearly shown with arrows returning to the loop condition.
8.3 Pseudocode
Pseudocode is an informal, human-readable description of an algorithm using plain English mixed
with programming-like constructs. It is not actual code and cannot be executed directly.
Common Pseudocode Keywords
INPUT / READ — to accept data from user
OUTPUT / PRINT / DISPLAY — to show results
SET / LET / ASSIGN — to assign values to variables
Computer Operator Exam Guide Page 17
ALGORITHMS — Computer Operator Exam Preparation Guide
IF ... THEN ... ELSE ... END IF — conditional
WHILE ... DO ... END WHILE — loop while condition is true
FOR i = start TO end ... END FOR — counted loop
FUNCTION / PROCEDURE ... END FUNCTION — define a module
RETURN — return a value from a function
CALL — invoke a function/procedure
Computer Operator Exam Guide Page 18
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 9: Types of Algorithms
Algorithms can be classified based on their design strategy, structure, or application area:
Type Description Examples
Brute Force Try all possible solutions Linear Search, Bubble Sort
exhaustively
Divide & Conquer Divide into subproblems, solve, Merge Sort, Binary Search
combine
Greedy Make the locally optimal choice Kruskal's, Dijkstra's, Huffman
at each step
Dynamic Store solutions to overlapping 0/1 Knapsack, LCS, Fibonacci
Programming subproblems
Backtracking Try all paths; abandon invalid N-Queens, Sudoku Solver
ones
Randomized Use random numbers in Randomized Quick Sort
algorithm logic
Recursive Function calls itself to solve Factorial, Tower of Hanoi
smaller cases
Iterative Use loops instead of recursion Iterative Factorial, Iterative BFS
9.1 Tower of Hanoi
Tower of Hanoi is a classic recursive problem involving three pegs and n disks. The goal is to move
all disks from source peg to destination peg following the rules:
• Only one disk can be moved at a time.
• A disk can only be placed on a larger disk (or empty peg).
• The total number of moves required = 2^n - 1
Key Formula
Minimum moves to solve Tower of Hanoi with n disks = 2^n - 1
For 3 disks: 2^3 - 1 = 7 moves
For 4 disks: 2^4 - 1 = 15 moves
Time Complexity: O(2^n) — Exponential
Computer Operator Exam Guide Page 19
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 10: Practice Questions & MCQs
The following Multiple Choice Questions are commonly asked in Computer Operator Examinations.
Study these carefully.
Section A: Algorithm Basics
1. Which of the following is NOT a property of a good algorithm?
• a) Finiteness
• b) Infinity
• c) Definiteness
• d) Effectiveness
Answer: b) Infinity — An algorithm must always terminate after a finite number of steps.
2. The time complexity of Binary Search is:
• a) O(n)
• b) O(n²)
• c) O(log n)
• d) O(n log n)
Answer: c) O(log n)
3. Which sorting algorithm has the best worst-case time complexity?
• a) Quick Sort
• b) Bubble Sort
• c) Merge Sort
• d) Selection Sort
Answer: c) Merge Sort — O(n log n) guaranteed in all cases.
4. A flowchart uses which symbol to represent a Decision?
• a) Rectangle
• b) Oval
• c) Diamond
• d) Parallelogram
Answer: c) Diamond
5. What is the minimum number of moves to solve Tower of Hanoi with 4 disks?
Computer Operator Exam Guide Page 20
ALGORITHMS — Computer Operator Exam Preparation Guide
• a) 8
• b) 15
• c) 16
• d) 7
Answer: b) 15 (2^4 - 1 = 15)
Section B: Complexity & Sorting
6. Which algorithm uses a Queue for its traversal?
• a) DFS
• b) BFS
• c) Binary Search
• d) Quick Sort
Answer: b) BFS — Breadth-First Search uses a Queue (FIFO).
7. Which of the following is a stable sorting algorithm?
• a) Quick Sort
• b) Heap Sort
• c) Selection Sort
• d) Merge Sort
Answer: d) Merge Sort
8. Dynamic Programming is most suitable when a problem has:
• a) Disjoint subproblems
• b) Overlapping subproblems and optimal substructure
• c) Only greedy choices
• d) No subproblems
Answer: b) Overlapping subproblems and optimal substructure
9. Which algorithm is used for data compression?
• a) Quick Sort
• b) Dijkstra's Algorithm
• c) Huffman Coding
• d) Binary Search
Answer: c) Huffman Coding — a greedy algorithm for lossless compression.
10. What is the space complexity of Merge Sort?
• a) O(1)
• b) O(log n)
Computer Operator Exam Guide Page 21
ALGORITHMS — Computer Operator Exam Preparation Guide
• c) O(n)
• d) O(n²)
Answer: c) O(n) — Merge Sort requires auxiliary space proportional to n.
Computer Operator Exam Guide Page 22
ALGORITHMS — Computer Operator Exam Preparation Guide
Chapter 11: Quick Reference Summary
Key Formulas to Remember
Topic Formula / Key Fact
Tower of Hanoi (n disks) Minimum moves = 2^n - 1
Binary Search Complexity O(log n) — worst case
Merge Sort Complexity O(n log n) — all cases
Fibonacci (recursive) Complexity O(2^n) — exponential (inefficient)
Fibonacci (DP) Complexity O(n) — linear (efficient)
DFS and BFS Complexity O(V + E) — vertices + edges
Factorial of n n! = n × (n-1) × ... × 2 × 1
Best sorting complexity possible O(n log n) — comparison-based sorting lower bound
Algorithm Design Paradigms Summary
Paradigm Key Idea When to Use
Brute Force Try everything Small inputs, simple problems
Divide & Conquer Split → solve → merge Large datasets, recursive problems
Greedy Best local choice Optimization, scheduling
Dynamic Cache subproblems Overlapping subproblems
Programming
Backtracking Try & undo failures Constraint satisfaction
Recursion Self-calling function Naturally recursive problems
Final Exam Tips
1. Always memorize the time and space complexity of ALL sorting and searching algorithms.
2. Know when to use BFS vs DFS — BFS for shortest path, DFS for cycle detection.
3. Understand the difference between Greedy and DP approaches.
4. Practice drawing flowcharts — know all symbols by heart.
5. For recursion problems, always identify the base case first.
6. Big-O notation: O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2^n) < O(n!).
Computer Operator Exam Guide Page 23
ALGORITHMS — Computer Operator Exam Preparation Guide
7. Merge Sort is the safest answer for 'best sorting algorithm' questions.
8. Binary Search requires a SORTED array — always state this condition.
Computer Operator Exam Guide Page 24