Last Updated : 12 Jul, 2025
The LOOK Disk Scheduling Algorithm is the advanced version of the SCAN (elevator) disk scheduling algorithm which gives slightly better seek time than any other algorithm in the hierarchy (FCFS->SRTF->SCAN->C-SCAN->LOOK). It is used to reduce the amount of time it takes to access data on a hard disk drive by minimizing the seek time between read/write operations. The LOOK algorithm operates by scanning the disk in a specific direction, but instead of going all the way to the end of the disk before reversing direction like the SCAN algorithm, it reverses direction as soon as it reaches the last request in the current direction.
The LOOK algorithm services request similarly to the SCAN Algorithm meanwhile it also "looks" ahead as if there are more tracks that are needed to be serviced in the same direction. The main reason behind the better performance of the LOOK algorithm in comparison to SCAN is that in this algorithm the head is not allowed to move till the end of the disk.
Steps Involved in the LOOK AlgorithmStep 1: Let the Request array represents an array storing indexes of tracks that have been requested in ascending order of their time of arrival. ‘head’ is the position of the disk head.
Step 2: The initial direction in which the head is moving is given and it services in the same direction.
Step 3: The head services all the requests one by one in the direction head is moving.
Step 4: The head continues to move in the same direction until all the requests in this direction are finished.
Step 5: While moving in this direction calculate the absolute distance of the track from the head.
Step 6: Increment the total seek count with this distance.
Step 7: Currently serviced track position now becomes the new head position.
Step 8: Go to step 5 until we reach at last request in this direction.
Step 9: If we reach where no requests are needed to be serviced in this direction reverse the direction and go to step 3 until all tracks in the request array have not been serviced.
ExampleInput:
Request sequence = {176, 79, 34, 60, 92, 11, 41, 114}
Initial head position = 50
Direction = right (We are moving from left to right)Output:
Initial position of head: 50
Total number of seek operations = 291
Seek Sequence: 60, 79, 92, 114, 176, 41, 34, 11
The following chart shows the sequence in which requested tracks are serviced using LOOK.
LOOK Disk Scheduling AlgorithmTherefore, the total seek count is calculated as
Total Seek Time = (60-50) + (79-60) + (92-79) + (114-92) + (176-114) + (176-41) + (41-34) + (34-11)Implementation of LOOK Disk Scheduling Algorithm
= 291
Implementation of the LOOK Algorithm is given below.
Note: The distance variable is used to store the absolute distance between the head and the current track position. disk_size is the size of the disk. Vectors left and right store all the request tracks on the left-hand side and the right-hand side of the initial head position respectively.
C++
// C++ program to demonstrate
// LOOK Disk Scheduling algorithm
int size = 8;
#include <bits/stdc++.h>
using namespace std;
// Code by Vikram Chaurasia
int disk_size = 200;
void LOOK(int arr[], int head, string direction)
{
int seek_count = 0;
int distance, cur_track;
vector<int> left, right;
vector<int> seek_sequence;
// appending values which are
// currently at left and right
// direction from the head.
for (int i = 0; i < size; i++) {
if (arr[i] < head)
left.push_back(arr[i]);
if (arr[i] > head)
right.push_back(arr[i]);
}
// sorting left and right vectors
// for servicing tracks in the
// correct sequence.
std::sort(left.begin(), left.end());
std::sort(right.begin(), right.end());
// run the while loop two times.
// one by one scanning right
// and left side of the head
int run = 2;
while (run--) {
if (direction == "left") {
for (int i = left.size() - 1; i >= 0; i--) {
cur_track = left[i];
// appending current track to seek sequence
seek_sequence.push_back(cur_track);
// calculate absolute distance
distance = abs(cur_track - head);
// increase the total count
seek_count += distance;
// accessed track is now the new head
head = cur_track;
}
// reversing the direction
direction = "right";
}
else if (direction == "right") {
for (int i = 0; i < right.size(); i++) {
cur_track = right[i];
// appending current track to seek sequence
seek_sequence.push_back(cur_track);
// calculate absolute distance
distance = abs(cur_track - head);
// increase the total count
seek_count += distance;
// accessed track is now new head
head = cur_track;
}
// reversing the direction
direction = "left";
}
}
cout << "Total number of seek operations = "
<< seek_count << endl;
cout << "Seek Sequence is" << endl;
for (int i = 0; i < seek_sequence.size(); i++) {
cout << seek_sequence[i] << endl;
}
}
// Driver code
int main()
{
// request array
int arr[size] = { 176, 79, 34, 60,
92, 11, 41, 114 };
int head = 50;
string direction = "right";
cout << "Initial position of head: "
<< head << endl;
LOOK(arr, head, direction);
return 0;
}
Java
// Java program to demonstrate
// LOOK Disk Scheduling algorithm
import java.util.*;
class GFG{
static int size = 8;
static int disk_size = 200;
public static void LOOK(int arr[], int head,
String direction)
{
int seek_count = 0;
int distance, cur_track;
Vector<Integer> left = new Vector<Integer>();
Vector<Integer> right = new Vector<Integer>();
Vector<Integer> seek_sequence = new Vector<Integer>();
// Appending values which are
// currently at left and right
// direction from the head.
for(int i = 0; i < size; i++)
{
if (arr[i] < head)
left.add(arr[i]);
if (arr[i] > head)
right.add(arr[i]);
}
// Sorting left and right vectors
// for servicing tracks in the
// correct sequence.
Collections.sort(left);
Collections.sort(right);
// Run the while loop two times.
// one by one scanning right
// and left side of the head
int run = 2;
while (run-- > 0)
{
if (direction == "left")
{
for(int i = left.size() - 1;
i >= 0; i--)
{
cur_track = left.get(i);
// Appending current track to
// seek sequence
seek_sequence.add(cur_track);
// Calculate absolute distance
distance = Math.abs(cur_track - head);
// Increase the total count
seek_count += distance;
// Accessed track is now the new head
head = cur_track;
}
// Reversing the direction
direction = "right";
}
else if (direction == "right")
{
for(int i = 0; i < right.size(); i++)
{
cur_track = right.get(i);
// Appending current track to
// seek sequence
seek_sequence.add(cur_track);
// Calculate absolute distance
distance = Math.abs(cur_track - head);
// Increase the total count
seek_count += distance;
// Accessed track is now new head
head = cur_track;
}
// Reversing the direction
direction = "left";
}
}
System.out.println("Total number of seek " +
"operations = " + seek_count);
System.out.println("Seek Sequence is");
for(int i = 0; i < seek_sequence.size(); i++)
{
System.out.println(seek_sequence.get(i));
}
}
// Driver code
public static void main(String[] args) throws Exception
{
// Request array
int arr[] = { 176, 79, 34, 60,
92, 11, 41, 114 };
int head = 50;
String direction = "right";
System.out.println("Initial position of head: " +
head);
LOOK(arr, head, direction);
}
}
// This code is contributed by divyesh072019
Python3
# Python3 program to demonstrate
# LOOK Disk Scheduling algorithm
size = 8
disk_size = 200
def LOOK(arr, head, direction):
seek_count = 0
distance = 0
cur_track = 0
left = []
right = []
seek_sequence = []
# Appending values which are
# currently at left and right
# direction from the head.
for i in range(size):
if (arr[i] < head):
left.append(arr[i])
if (arr[i] > head):
right.append(arr[i])
# Sorting left and right vectors
# for servicing tracks in the
# correct sequence.
left.sort()
right.sort()
# Run the while loop two times.
# one by one scanning right
# and left side of the head
run = 2
while (run):
if (direction == "left"):
for i in range(len(left) - 1, -1, -1):
cur_track = left[i]
# Appending current track to
# seek sequence
seek_sequence.append(cur_track)
# Calculate absolute distance
distance = abs(cur_track - head)
# Increase the total count
seek_count += distance
# Accessed track is now the new head
head = cur_track
# Reversing the direction
direction = "right"
elif (direction == "right"):
for i in range(len(right)):
cur_track = right[i]
# Appending current track to
# seek sequence
seek_sequence.append(cur_track)
# Calculate absolute distance
distance = abs(cur_track - head)
# Increase the total count
seek_count += distance
# Accessed track is now new head
head = cur_track
# Reversing the direction
direction = "left"
run -= 1
print("Total number of seek operations =",
seek_count)
print("Seek Sequence is")
for i in range(len(seek_sequence)):
print(seek_sequence[i])
# Driver code
# Request array
arr = [ 176, 79, 34, 60, 92, 11, 41, 114 ]
head = 50
direction = "right"
print("Initial position of head:", head)
LOOK(arr, head, direction)
# This code is contributed by rag2127
C#
// C# program to demonstrate
// LOOK Disk Scheduling algorithm
using System;
using System.Collections.Generic;
class GFG{
static int size = 8;
static void LOOK(int[] arr, int head,
string direction)
{
int seek_count = 0;
int distance, cur_track;
List<int> left = new List<int>();
List<int> right = new List<int>();
List<int> seek_sequence = new List<int>();
// Appending values which are
// currently at left and right
// direction from the head.
for(int i = 0; i < size; i++)
{
if (arr[i] < head)
left.Add(arr[i]);
if (arr[i] > head)
right.Add(arr[i]);
}
// Sorting left and right vectors
// for servicing tracks in the
// correct sequence.
left.Sort();
right.Sort();
// Run the while loop two times.
// one by one scanning right
// and left side of the head
int run = 2;
while (run-- > 0)
{
if (direction == "left")
{
for(int i = left.Count - 1; i >= 0; i--)
{
cur_track = left[i];
// Appending current track to
// seek sequence
seek_sequence.Add(cur_track);
// Calculate absolute distance
distance = Math.Abs(cur_track - head);
// Increase the total count
seek_count += distance;
// Accessed track is now the new head
head = cur_track;
}
// Reversing the direction
direction = "right";
}
else if (direction == "right")
{
for(int i = 0; i < right.Count; i++)
{
cur_track = right[i];
// Appending current track to
// seek sequence
seek_sequence.Add(cur_track);
// Calculate absolute distance
distance = Math.Abs(cur_track - head);
// Increase the total count
seek_count += distance;
// Accessed track is now new head
head = cur_track;
}
// Reversing the direction
direction = "left";
}
}
Console.WriteLine("Total number of seek " +
"operations = " + seek_count);
Console.WriteLine("Seek Sequence is");
for(int i = 0; i < seek_sequence.Count; i++)
{
Console.WriteLine(seek_sequence[i]);
}
}
// Driver code
static void Main()
{
// Request array
int[] arr = { 176, 79, 34, 60,
92, 11, 41, 114 };
int head = 50;
string direction = "right";
Console.WriteLine("Initial position of head: " +
head);
LOOK(arr, head, direction);
}
}
// This code is contributed by divyeshrabadiya07
JavaScript
<script>
// Javascript program to demonstrate
// LOOK Disk Scheduling algorithm
let size = 8;
function LOOK(arr, head, direction)
{
let seek_count = 0;
let distance, cur_track;
let left = [];
let right = [];
let seek_sequence = [];
// Appending values which are
// currently at left and right
// direction from the head.
for(let i = 0; i < size; i++)
{
if (arr[i] < head)
left.push(arr[i]);
if (arr[i] > head)
right.push(arr[i]);
}
// Sorting left and right vectors
// for servicing tracks in the
// correct sequence.
left.sort(function(a, b){return a - b});
right.sort(function(a, b){return a - b});
// Run the while loop two times.
// one by one scanning right
// and left side of the head
let run = 2;
while (run-- > 0)
{
if (direction == "left")
{
for(let i = left.length - 1; i >= 0; i--)
{
cur_track = left[i];
// Appending current track to
// seek sequence
seek_sequence.push(cur_track);
// Calculate absolute distance
distance = Math.abs(cur_track - head);
// Increase the total count
seek_count += distance;
// Accessed track is now the new head
head = cur_track;
}
// Reversing the direction
direction = "right";
}
else if (direction == "right")
{
for(let i = 0; i < right.length; i++)
{
cur_track = right[i];
// Appending current track to
// seek sequence
seek_sequence.push(cur_track);
// Calculate absolute distance
distance = Math.abs(cur_track - head);
// Increase the total count
seek_count += distance;
// Accessed track is now new head
head = cur_track;
}
// Reversing the direction
direction = "left";
}
}
document.write("Total number of seek " +
"operations = " + seek_count + "</br>");
document.write("Seek Sequence is" + "</br>");
for(let i = 0; i < seek_sequence.length; i++)
{
document.write(seek_sequence[i] + "</br>");
}
}
// Request array
let arr = [176, 79, 34, 60, 92, 11, 41, 114];
let head = 50;
let direction = "right";
document.write("Initial position of head: " + head + "</br>");
LOOK(arr, head, direction);
</script>
Output
Initial position of head: 50
Total number of seek operations = 291
Seek Sequence: 60, 79, 92, 114, 176, 41, 34, 11
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4