C-SCAN (circular SCAN) in Operating Systems - Time & Space Complexity
Analyzing time complexity helps us understand how the C-SCAN disk scheduling algorithm performs as the number of disk requests grows.
We want to know how the total work changes when more requests arrive.
Analyze the time complexity of the following C-SCAN scheduling process.
function cscan(requests, head, disk_size) {
requests.sort()
let total_movement = 0
let index = 0;
while (index < requests.length && requests[index] < head) {
index++;
}
for (let i = index; i < requests.length; i++) {
total_movement += Math.abs(requests[i] - head)
head = requests[i]
}
total_movement += Math.abs(disk_size - 1 - head) + (disk_size - 1)
head = 0
for (let i = 0; i < index; i++) {
total_movement += Math.abs(requests[i] - head)
head = requests[i]
}
return total_movement
}
This code moves the disk head from its current position to the end, then jumps to the start, and services all requests in a circular manner.
Look for loops or repeated steps that process requests.
- Primary operation: Two loops each scanning part of the sorted request list.
- How many times: Each request is visited exactly once in total.
As the number of requests increases, the algorithm processes each request once in order.
| Input Size (n) | Approx. Operations |
|---|---|
| 10 | About 10 steps to move and service requests |
| 100 | About 100 steps |
| 1000 | About 1000 steps |
Pattern observation: The work grows roughly in direct proportion to the number of requests.
Time Complexity: O(n log n)
This means the time grows a bit faster than the number of requests because sorting is needed, but each request is only handled once.
[X] Wrong: "The C-SCAN algorithm runs in linear time because it just moves through requests once."
[OK] Correct: Sorting the requests first takes extra time, which grows faster than just scanning, so the total time is not purely linear.
Understanding how C-SCAN scales helps you explain disk scheduling efficiency clearly, showing you grasp both algorithm steps and their cost.
"What if the requests were already sorted? How would that affect the time complexity of C-SCAN?"
Practice
Solution
Step 1: Understand C-SCAN movement
C-SCAN moves the disk arm in one direction only, serving requests along the way.Step 2: Identify behavior at the end of the disk
After reaching the last track, it jumps back to the first track without serving requests during the return.Final Answer:
The disk arm moves in one direction and jumps back to the start without serving requests on return. -> Option BQuick Check:
C-SCAN moves one way and jumps back = A [OK]
- Thinking C-SCAN moves back and forth like SCAN
- Assuming requests are served during the return jump
- Confusing C-SCAN with random or nearest request scheduling
Solution
Step 1: Analyze the jump behavior in C-SCAN
C-SCAN jumps back to the first track after reaching the last track.Step 2: Check if requests are served during the jump
Requests are not served during this jump; the arm moves quickly without processing.Final Answer:
The disk arm jumps back to the first track without serving any requests during the jump. -> Option AQuick Check:
Jump without serving requests = D [OK]
- Assuming requests are served during the jump
- Confusing jump with reversing direction
- Thinking the arm waits before jumping
Solution
Step 1: Identify requests ahead of current position
Requests are at 34, 95, 119, 180. Current position is 50. C-SCAN moves forward only, so it serves requests with track numbers greater than 50 first: 95, 119, 180.Step 2: Find the nearest request ahead
The nearest request ahead is at track 95, so it will be served immediately after 50.Final Answer:
95 -> Option AQuick Check:
Next request after 50 going forward = 95 [OK]
- Serving requests behind current position before forward ones
- Choosing the closest track number regardless of direction
- Confusing C-SCAN with SCAN which moves back and forth
Solution
Step 1: Review C-SCAN jump behavior
C-SCAN moves forward serving requests, then jumps back to the first track without serving requests during the jump.Step 2: Identify the error in the student's statement
The student incorrectly said requests are served during the jump back, which is false.Final Answer:
C-SCAN serves requests only while moving forward, not during the jump back. -> Option CQuick Check:
Requests served only forward, not on jump = C [OK]
- Thinking C-SCAN reverses direction instead of jumping
- Assuming requests are served during the jump
- Confusing C-SCAN with SCAN algorithm
Solution
Step 1: Identify requests ahead of current position 150
Requests ahead are 170 and 190. C-SCAN serves these first moving forward.Step 2: After reaching last track, jump to start and serve remaining requests
After 190, the arm jumps to track 0 and serves requests at 10, 15, and 30 in ascending order.Final Answer:
170, 190, 10, 15, 30 -> Option DQuick Check:
Serve forward requests, jump, then serve from start = A [OK]
- Serving requests behind current position before forward ones
- Serving requests in descending order
- Ignoring the jump and serving requests in wrong order
Ready to prove it?
Pass the test and this pattern moves unknown
