1、先來先服務（FCFS）

FCFS演算法根據程序請求訪問磁碟的先後順序進行排程，這是一種最簡單的排程演算法。

此演算法的優點是公平、簡單，每個程序的請求都能依此得到處理，但缺點是磁頭移動的距離和平均移動距離會很大。

2、最短尋道時間優先（SSTF）

 SSTF演算法選擇排程處理的磁軌是與當前磁頭所在磁軌距離最近的磁軌，以使每次的尋找時間最短。

當然，總是選擇最小尋找時間並不能保證平均尋找時間最小，但是能提供比FCFS演算法更好的效能。

3、掃描演算法（SCAN）

SCAN演算法在磁頭當前移動方向上選擇與當前磁頭所在磁軌距離最近的請求作為下一次服務的物件。

4、迴圈掃描演算法（CSCAN）

在掃描演算法的基礎上規定磁頭單向移動來提供服務，回返時直接快速移動至起始端而不服務任何請求。

data:

100
55 58 39 18 90 160 150 38 184

FCFS：

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data


def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length



l = 0
start, data = loaddata('data')
for d in data.split():
    l += loadNext(start, d)
    start = d
n = len(data.split())
print("FIFO:平均尋道長度：%.1f" %(l/n))
 

SSTF:

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data

def findNextIndex(start,datas):
    length = []
    for data in datas:
        l = abs(int(start) - int(data))
        length.append(l)
    minIndex = length.index(min(length))
    return minIndex

def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length

l = 0
start,data = loaddata('data')
data2 = data.split().copy()
n = len(data2)
for d in data.split():
    nextIndex = findNextIndex(start,data2)
    l += loadNext(start,data2[nextIndex])
    start = data2[nextIndex]
    data2.remove(data2[nextIndex])

print("FIFO:平均尋道長度：%.1f" %(l/n))


 

SCAN:

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data


def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length

def findNext(now,data):
    biggerList = []
    smallerList = []
    for d in data:
        if int(d) > int(now):
            biggerList.append(d)
    if (len(biggerList)==0):
        if len(data)!=0:
            for d2 in data:
                if int(d2)<int(now):
                    smallerList.append(d2)
            return max(smallerList)
        else:
            return None
    return min(biggerList)



l = 0
start,data = loaddata('data')
data2 = data.split().copy()
n = len(data2)
for d in data :
    next = findNext(start,data2)
    if next == None:
        break
    l += loadNext(start,next)
    start = next
    data2.remove(next)
print("FIFO:平均尋道長度：%.1f" %(l/n))

CSCAN:

def loaddata(fileName):
    f = open(fileName)
    start = f.readline()
    data = f.readline()
    return start, data


def loadNext(now, next):
    length = abs(int(now) - int(next))
    print(next, length)
    return length

def findNext(now,data):
    biggerList = []
    smallerList = []
    for d in data:
        if int(d) > int(now):
            biggerList.append(d)
    if (len(biggerList)==0):
        if len(data) != 0:
            now = 0
            return(findNext(now,data))
        else:
            return None
    return min(biggerList)



l = 0
start,data = loaddata('data')
data2 = data.split().copy()
n = len(data2)
for d in data :
    next = findNext(start,data2)
    if next == None:
        break
    l += loadNext(start,next)
    start = next
    data2.remove(next)
print("FIFO:平均尋道長度：%.1f" %(l/n))