디스크 스케줄링

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_TRACK 199
#define N         8

int requests[N] = {98, 183, 37, 122, 14, 124, 65, 67};
int head = 53;

/* ── FCFS ─────────────────────────────────────── */
int fcfs() {
    int cur = head, dist = 0;
    for (int i = 0; i < N; i++) {
        dist += abs(requests[i] - cur);
        cur   = requests[i];
    }
    return dist;
}

/* ── SSTF ─────────────────────────────────────── */
int sstf() {
    int rem[N], n = N, cur = head, dist = 0;
    memcpy(rem, requests, sizeof(requests));

    while (n > 0) {
        int minD = 99999, idx = 0;
        for (int i = 0; i < n; i++) {
            int d = abs(rem[i] - cur);
            if (d < minD) { minD = d; idx = i; }
        }
        dist += minD;
        cur   = rem[idx];
        rem[idx] = rem[--n];   // 처리된 요청 제거
    }
    return dist;
}

/* ── SCAN ─────────────────────────────────────── */
int scan() {
    int sorted[N], cur = head, dist = 0;
    memcpy(sorted, requests, sizeof(requests));

    // 오름차순 정렬
    for (int i = 0; i < N-1; i++)
        for (int j = i+1; j < N; j++)
            if (sorted[j] < sorted[i]) {
                int tmp = sorted[i]; sorted[i] = sorted[j]; sorted[j] = tmp;
            }

    // 위 방향: 헤드 이상 요청을 오름차순으로 처리
    for (int i = 0; i < N; i++)
        if (sorted[i] >= head) { dist += abs(sorted[i] - cur); cur = sorted[i]; }

    // 디스크 끝(MAX_TRACK)까지 이동 후 방향 전환
    dist += abs(MAX_TRACK - cur); cur = MAX_TRACK;

    // 아래 방향: 헤드 미만 요청을 내림차순으로 처리
    for (int i = N-1; i >= 0; i--)
        if (sorted[i] < head) { dist += abs(sorted[i] - cur); cur = sorted[i]; }
    return dist;
}

int main() {
    printf("FCFS   총 이동: %d 트랙\n", fcfs());
    printf("SSTF   총 이동: %d 트랙\n", sstf());
    printf("SCAN   총 이동: %d 트랙\n", scan());
    return 0;
}

import java.util.*;

public class DiskScheduler {

    static final int HEAD  = 53;
    static final int[] REQ = {98, 183, 37, 122, 14, 124, 65, 67};

    /** SSTF: 현재 위치 기준 가장 가까운 트랙을 우선 처리 */
    static int sstf(int head, int[] requests) {
        List<Integer> rem = new ArrayList<>();
        for (int r : requests) rem.add(r);

        int cur = head, total = 0;
        System.out.printf("HEAD: %d%n", cur);

        while (!rem.isEmpty()) {
            // 가장 가까운 트랙 탐색
            int finalCur = cur;
            rem.sort(Comparator.comparingInt(t -> Math.abs(t - finalCur)));

            int next = rem.remove(0);
            int dist = Math.abs(next - cur);
            total += dist;

            System.out.printf("%d → %d  (거리: %d, 누적: %d)%n",
                cur, next, dist, total);
            cur = next;
        }
        return total;
    }

    /** C-SCAN: 한 방향으로만, 끝에서 0으로 점프 */
    static int cscan(int head, int[] requests) {
        int[] sorted = requests.clone();
        Arrays.sort(sorted);

        List<Integer> order = new ArrayList<>();

        // head 이상: 오름차순
        for (int t : sorted) if (t >= head) order.add(t);
        // 끝(199)까지 이동 후 0으로 점프
        order.add(199);
        order.add(0);
        // head 미만: 오름차순
        for (int t : sorted) if (t < head) order.add(t);

        int cur = head, total = 0;
        for (int next : order) {
            total += Math.abs(next - cur);
            cur    = next;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println("=== SSTF ===");
        int d1 = sstf(HEAD, REQ);
        System.out.println("총 이동: " + d1 + " 트랙\n");

        System.out.println("=== C-SCAN ===");
        int d2 = cscan(HEAD, REQ);
        System.out.println("총 이동: " + d2 + " 트랙");
    }
}