首次适应算法，循环首次适应算法，最佳适应算法，最坏适应算法一起使用C语言实现代码

以下是四种内存分配算法的C语言实现代码：

### 首次适应算法（First Fit）

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

#define MAX_SIZE 1024  // 内存大小
#define MAX_PROCESS 10  // 进程数量

int block[MAX_SIZE];  // 内存块数组
int process[MAX_PROCESS];  // 进程数组

void init() {
    for (int i = 0; i < MAX_SIZE; i++) {
        block[i] = 0;
    }
    for (int i = 0; i < MAX_PROCESS; i++) {
        process[i] = rand() % 100 + 1;  // 随机生成进程大小
    }
}

int first_fit(int size) {
    for (int i = 0; i < MAX_SIZE; i++) {
        if (block[i] == 0) {  // 找到一个未被使用的内存块
            int j = i;
            while (j < MAX_SIZE && block[j] == 0) {  // 找到连续的空闲区域
                j++;
            }
            if (j - i >= size) {  // 如果空闲区域能够容纳进程
                return i;  // 返回起始地址
            }
            i = j;  // 跳过已经扫描的空闲区域
        }
    }
    return -1;  // 没有找到合适的内存块
}

void allocate(int algorithm) {
    printf("进程大小：");
    for (int i = 0; i < MAX_PROCESS; i++) {
        printf("%d ", process[i]);
    }
    printf("\n");

    for (int i = 0; i < MAX_PROCESS; i++) {
        int address = -1;
        switch (algorithm) {
            case 1:  // 首次适应算法
                address = first_fit(process[i]);
                break;
            case 2:  // 循环首次适应算法
                // TODO
                break;
            case 3:  // 最佳适应算法
                // TODO
                break;
            case 4:  // 最坏适应算法
                // TODO
                break;
            default:
                break;
        }

        if (address != -1) {
            printf("进程 %d 被分配到内存块的起始地址为 %d\n", i, address);
            for (int j = address; j < address + process[i]; j++) {
                block[j] = 1;  // 标记已被使用
            }
        } else {
            printf("无法分配进程 %d\n", i);
        }
    }
}

int main() {
    init();
    allocate(1);  // 首次适应算法
    return 0;
}

### 循环首次适应算法（Next Fit）

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

#define MAX_SIZE 1024  // 内存大小
#define MAX_PROCESS 10  // 进程数量

int block[MAX_SIZE];  // 内存块数组
int process[MAX_PROCESS];  // 进程数组

void init() {
    for (int i = 0; i < MAX_SIZE; i++) {
        block[i] = 0;
    }
    for (int i = 0; i < MAX_PROCESS; i++) {
        process[i] = rand() % 100 + 1;  // 随机生成进程大小
    }
}

int next_fit(int size, int start) {
    for (int i = start; i < MAX_SIZE; i++) {
        if (block[i] == 0) {  // 找到一个未被使用的内存块
            int j = i;
            while (j < MAX_SIZE && block[j] == 0) {  // 找到连续的空闲区域
                j++;
            }
            if (j - i >= size) {  // 如果空闲区域能够容纳进程
                return i;  // 返回起始地址
            }
            i = j;  // 跳过已经扫描的空闲区域
        }
    }
    return -1;  // 没有找到合适的内存块
}

void allocate(int algorithm) {
    printf("进程大小：");
    for (int i = 0; i < MAX_PROCESS; i++) {
        printf("%d ", process[i]);
    }
    printf("\n");

    int start = 0;
    for (int i = 0; i < MAX_PROCESS; i++) {
        int address = -1;
        switch (algorithm) {
            case 1:  // 首次适应算法
                // TODO
                break;
            case 2:  // 循环首次适应算法
                address = next_fit(process[i], start);
                break;
            case 3:  // 最佳适应算法
                // TODO
                break;
            case 4:  // 最坏适应算法
                // TODO
                break;
            default:
                break;
        }

        if (address != -1) {
            printf("进程 %d 被分配到内存块的起始地址为 %d\n", i, address);
            for (int j = address; j < address + process[i]; j++) {
                block[j] = 1;  // 标记已被使用
            }
            start = address;  // 记录下一个起始地址
        } else {
            printf("无法分配进程 %d\n", i);
        }
    }
}

int main() {
    init();
    allocate(2);  // 循环首次适应算法
    return 0;
}

### 最佳适应算法（Best Fit）

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

#define MAX_SIZE 1024  // 内存大小
#define MAX_PROCESS 10  // 进程数量

int block[MAX_SIZE];  // 内存块数组
int process[MAX_PROCESS];  // 进程数组

void init() {
    for (int i = 0; i < MAX_SIZE; i++) {
        block[i] = 0;
    }
    for (int i = 0; i < MAX_PROCESS; i++) {
        process[i] = rand() % 100 + 1;  // 随机生成进程大小
    }
}

int best_fit(int size) {
    int min_size = MAX_SIZE;
    int address = -1;
    for (int i = 0; i < MAX_SIZE; i++) {
        if (block[i] == 0) {  // 找到一个未被使用的内存块
            int j = i;
            while (j < MAX_SIZE && block[j] == 0) {  // 找到连续的空闲区域
                j++;
            }
            if (j - i >= size && j - i < min_size) {  // 如果空闲区域能够容纳进程且更小
                min_size = j - i;
                address = i;  // 记录起始地址
            }
            i = j;  // 跳过已经扫描的空闲区域
        }
    }
    return address;  // 返回最佳起始地址
}

void allocate(int algorithm) {
    printf("进程大小：");
    for (int i = 0; i < MAX_PROCESS; i++) {
        printf("%d ", process[i]);
    }
    printf("\n");

    for (int i = 0; i < MAX_PROCESS; i++) {
        int address = -1;
        switch (algorithm) {
            case 1:  // 首次适应算法
                // TODO
                break;
            case 2:  // 循环首次适应算法
                // TODO
                break;
            case 3:  // 最佳适应算法
                address = best_fit(process[i]);
                break;
            case 4:  // 最坏适应算法
                // TODO
                break;
            default:
                break;
        }

        if (address != -1) {
            printf("进程 %d 被分配到内存块的起始地址为 %d\n", i, address);
            for (int j = address; j < address + process[i]; j++) {
                block[j] = 1;  // 标记已被使用
            }
        } else {
            printf("无法分配进程 %d\n", i);
        }
    }
}

int main() {
    init();
    allocate(3);  // 最佳适应算法
    return 0;
}

### 最坏适应算法（Worst Fit）

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

#define MAX_SIZE 1024  // 内存大小
#define MAX_PROCESS 10  // 进程数量

int block[MAX_SIZE];  // 内存块数组
int process[MAX_PROCESS];  // 进程数组

void init() {
    for (int i = 0; i < MAX_SIZE; i++) {
        block[i] = 0;
    }
    for (int i = 0; i < MAX_PROCESS; i++) {
        process[i] = rand() % 100 + 1;  // 随机生成进程大小
    }
}

int worst_fit(int size) {
    int max_size = 0;
    int address = -1;
    for (int i = 0; i < MAX_SIZE; i++) {
        if (block[i] == 0) {  // 找到一个未被使用的内存块
            int j = i;
            while (j < MAX_SIZE && block[j] == 0) {  // 找到连续的空闲区域
                j++;
            }
            if (j - i >= size && j - i > max_size) {  // 如果空闲区域能够容纳进程且更大
                max_size = j - i;
                address = i;  // 记录起始地址
            }
            i = j;  // 跳过已经扫描的空闲区域
        }
    }
    return address;  // 返回最坏起始地址
}

void allocate(int algorithm) {
    printf("进程大小：");
    for (int i = 0; i < MAX_PROCESS; i++) {
        printf("%d ", process[i]);
    }
    printf("\n");

    for (int i = 0; i < MAX_PROCESS; i++) {
        int address = -1;
        switch (algorithm) {
            case 1:  // 首次适应算法
                // TODO
                break;
            case 2:  // 循环首次适应算法
                // TODO
                break;
            case 3:  // 最佳适应算法
                // TODO
                break;
            case 4:  // 最坏适应算法
                address = worst_fit(process[i]);
                break;
            default:
                break;
        }

        if (address != -1) {
            printf("进程 %d 被分配到内存块的起始地址为 %d\n", i, address);
            for (int j = address; j < address + process[i]; j++) {
                block[j] = 1;  // 标记已被使用
            }
        } else {
            printf("无法分配进程 %d\n", i);
        }
    }
}

int main() {
    init();
    allocate(4);  // 最坏适应算法
    return 0;
}