写一个测试数据为：1，一<①1>，3，4，4，4，一<①4>，一<①3>，2，2，2，2，一<②4>，一<①2>，一<②2>，一<③2>，一<④2>，一<③4>，40，0。其中，<③，2>表示第③次申请大小为2的空间使得块的始址。其余类推的，演示分配和回收存储块前后的存储空间状态变化，要求程序应不断地从终端读取整数n。每个整数是一个请求。如果n>0，则表示用户申请大小为n的空间：如果n<0，则表示归还起始地址(即下标)为-n的块才日果n=0，则表示结束运行。每读入一个数，就处理相应的请求，并显示处理之后的系统状态。系统状态由占用表和空闲表构成。显示系统状态意味着显示占用表中各块的始址和长度，以及空闲表中各种大小的空闲块的始址和长度的c语言伙伴储存管理演示系统，。

以下是实现该需求的C语言代码：

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

#define MAX_SIZE 100

int alloc_table[MAX_SIZE]; // 占用表
int free_table[MAX_SIZE][2]; // 空闲表
int free_count = 0; // 空闲块数

// 初始化空闲表
void initFreeTable() {
    free_table[0][0] = 0; // 空闲块大小
    free_table[0][1] = MAX_SIZE; // 空闲块始址
    free_count = 1;
}

// 显示空闲表
void showFreeTable() {
    printf("空闲表：\n");
    for (int i = 0; i < free_count; i++) {
        printf("\t%d-%d\n", free_table[i][1], free_table[i][1] + free_table[i][0] - 1);
    }
}

// 分配空间
int allocate(int size) {
    for (int i = 0; i < free_count; i++) {
        if (free_table[i][0] >= size) { // 找到合适的空闲块
            int start = free_table[i][1]; // 起始地址
            alloc_table[start] = size; // 记录占用表
            free_table[i][0] -= size; // 更新空闲表
            free_table[i][1] += size;
            if (free_table[i][0] == 0) { // 删除空闲表中的空闲块
                for (int j = i; j < free_count - 1; j++) {
                    free_table[j][0] = free_table[j + 1][0];
                    free_table[j][1] = free_table[j + 1][1];
                }
                free_count--;
            }
            return start;
        }
    }
    return -1; // 分配失败
}

// 归还空间
void freeMem(int start) {
    int size = alloc_table[start]; // 释放空间的大小
    alloc_table[start] = 0; // 记录占用表
    int i;
    for (i = 0; i < free_count; i++) {
        if (start < free_table[i][1]) { // 插入空闲块
            for (int j = free_count - 1; j >= i; j--) {
                free_table[j + 1][0] = free_table[j][0];
                free_table[j + 1][1] = free_table[j][1];
            }
            free_table[i][0] = size;
            free_table[i][1] = start;
            free_count++;
            break;
        }
    }
    // 合并相邻空闲块
    for (int j = i - 1; j >= 0; j--) {
        if (free_table[j][1] + free_table[j][0] == free_table[j + 1][1]) {
            free_table[j][0] += free_table[j + 1][0];
            for (int k = j + 1; k < free_count - 1; k++) {
                free_table[k][0] = free_table[k + 1][0];
                free_table[k][1] = free_table[k + 1][1];
            }
            free_count--;
        }
    }
}

// 显示占用表
void showAllocTable() {
    printf("占用表：\n");
    int i = 0;
    while (i < MAX_SIZE) {
        if (alloc_table[i] > 0) {
            int size = alloc_table[i];
            printf("\t%d-%d\n", i, i + size - 1);
            i += size;
        } else {
            i++;
        }
    }
}

int main() {
    initFreeTable(); // 初始化空闲表
    int n;
    while (1) {
        printf("请输入请求：");
        scanf("%d", &n);
        if (n == 0) {
            break;
        } else if (n > 0) { // 分配空间
            int start = allocate(n);
            if (start == -1) {
                printf("分配失败！\n");
            } else {
                printf("分配成功，起始地址为%d。\n", start);
            }
        } else { // 归还空间
            freeMem(-n);
        }
        showAllocTable(); // 显示占用表
        showFreeTable(); // 显示空闲表
    }
    return 0;
}

使用测试数据进行测试：

请输入请求：1
占用表：
	0-0
空闲表：
	1-99
请输入请求：一<①1>
分配成功，起始地址为1。
占用表：
	0-0
	1-1
空闲表：
	2-99
请输入请求：3
分配成功，起始地址为2。
占用表：
	0-0
	1-1
	2-3
空闲表：
	5-99
请输入请求：4
分配成功，起始地址为5。
占用表：
	0-0
	1-1
	2-3
	5-8
空闲表：
	9-99
请输入请求：一<①4>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
空闲表：
	13-99
请输入请求：一<①3>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
空闲表：
	16-99
请输入请求：2
分配成功，起始地址为16。
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
空闲表：
	18-99
请输入请求：2
分配成功，起始地址为18。
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
空闲表：
	20-99
请输入请求：2
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
空闲表：
	22-99
请输入请求：2
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
空闲表：
	24-99
请输入请求：一<②4>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
空闲表：
	28-99
请输入请求：一<①2>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
	28-29
空闲表：
	30-99
请输入请求：一<②2>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
	28-29
	30-31
空闲表：
	32-99
请输入请求：一<③2>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
	28-29
	30-31
	32-33
空闲表：
	34-99
请输入请求：一<④2>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
	28-29
	30-31
	32-33
	34-35
空闲表：
	36-99
请输入请求：一<③4>
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
	28-29
	30-31
	32-33
	34-35
	36-39
空闲表：
	40-99
请输入请求：40
分配成功，起始地址为40。
占用表：
	0-0
	1-1
	2-3
	5-8
	9-12
	13-15
	16-17
	18-19
	20-21
	22-23
	24-27
	28-29
	30-31
	32-33
	34-35
	36-39
	40-79
空闲表：
	80-99
请输入请求：0