内存分配(分别用三个算法）、回收与合并过程的程序C语言

以下是三种内存分配算法（首次适应算法、最佳适应算法和最差适应算法）和内存回收与合并过程的C语言程序示例。

1. 首次适应算法：

#define MAX_MEMORY_SIZE 1000 //最大内存大小
int memory[MAX_MEMORY_SIZE]; //内存数组，0表示空闲，1表示占用
int allocate(int size) //分配内存
{
    int i, j, start = -1;
    for (i = 0; i < MAX_MEMORY_SIZE; i++) {
        if (memory[i] == 0) { //找到空闲区域
            start = i;
            for (j = i; j < i + size; j++) {
                if (j >= MAX_MEMORY_SIZE || memory[j] == 1) { //空闲区域不足
                    start = -1;
                    break;
                }
            }
            if (start != -1) { //找到足够大的区域
                for (j = start; j < start + size; j++) {
                    memory[j] = 1; //标记为占用
                }
                return start; //返回起始位置
            }
        }
    }
    return -1; //找不到足够大的区域
}
void free(int start, int size) //释放内存
{
    int i;
    for (i = start; i < start + size; i++) {
        memory[i] = 0; //标记为空闲
    }
}

2. 最佳适应算法：

#define MAX_MEMORY_SIZE 1000 //最大内存大小
int memory[MAX_MEMORY_SIZE]; //内存数组，0表示空闲，1表示占用
int allocate(int size) //分配内存
{
    int i, j, start = -1, min_size = MAX_MEMORY_SIZE;
    for (i = 0; i < MAX_MEMORY_SIZE; i++) {
        if (memory[i] == 0) { //找到空闲区域
            for (j = i; j < i + size; j++) {
                if (j >= MAX_MEMORY_SIZE || memory[j] == 1) { //空闲区域不足
                    break;
                }
            }
            if (j - i >= size && j - i < min_size) { //找到更小的空闲区域
                start = i;
                min_size = j - i;
            }
        }
    }
    if (start != -1) { //找到足够大的区域
        for (j = start; j < start + size; j++) {
            memory[j] = 1; //标记为占用
        }
        return start; //返回起始位置
    }
    return -1; //找不到足够大的区域
}
void free(int start, int size) //释放内存
{
    int i;
    for (i = start; i < start + size; i++) {
        memory[i] = 0; //标记为空闲
    }
}

3. 最差适应算法：

#define MAX_MEMORY_SIZE 1000 //最大内存大小
int memory[MAX_MEMORY_SIZE]; //内存数组，0表示空闲，1表示占用
int allocate(int size) //分配内存
{
    int i, j, start = -1, max_size = 0;
    for (i = 0; i < MAX_MEMORY_SIZE; i++) {
        if (memory[i] == 0) { //找到空闲区域
            for (j = i; j < i + size; j++) {
                if (j >= MAX_MEMORY_SIZE || memory[j] == 1) { //空闲区域不足
                    break;
                }
            }
            if (j - i >= size && j - i > max_size) { //找到更大的空闲区域
                start = i;
                max_size = j - i;
            }
        }
    }
    if (start != -1) { //找到足够大的区域
        for (j = start; j < start + size; j++) {
            memory[j] = 1; //标记为占用
        }
        return start; //返回起始位置
    }
    return -1; //找不到足够大的区域
}
void free(int start, int size) //释放内存
{
    int i;
    for (i = start; i < start + size; i++) {
        memory[i] = 0; //标记为空闲
    }
}

以上三个算法中的内存回收和合并过程都相同，即将被释放的内存块标记为空闲，如果相邻的空闲块可以合并，则进行合并操作。合并操作可以通过遍历内存数组来实现。