在c89标准下用c语言编写一个银行家算法，要求有五个进程四个资源，并且给定三种数据输出三中结果分别是分配成功并输出安全序列，分配不成功，预分配成功但安全性检查未通过所以分配不成功

### 回答1：
以下是在C89标准下使用C语言编写的银行家算法，具有五个进程、四个资源，可以输出三种结果，分别是分配成功并输出安全序列，分配不成功，预分配成功但安全性检查未通过所以分配不成功。

#include <stdio.h>
#include <stdbool.h>

#define N 5
#define M 4

int available[M] = {3, 3, 2, 2};

int max[N][M] = {
    {7, 5, 3, 2},
    {3, 2, 2, 2},
    {9, 0, 2, 2},
    {2, 2, 2, 2},
    {4, 3, 3, 3}
};

int allocation[N][M] = {
    {0, 1, 0, 0},
    {2, 0, 0, 1},
    {3, 0, 2, 1},
    {2, 1, 1, 1},
    {0, 0, 2, 0}
};

int need[N][M];

bool finish[N] = {false};

int work[M];

void init_need() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            need[i][j] = max[i][j] - allocation[i][j];
        }
    }
}

bool check(int i) {
    for (int j = 0; j < M; j++) {
        if (need[i][j] > work[j]) {
            return false;
        }
    }
    return true;
}

bool safe_check() {
    init_need();

    for (int i = 0; i < M; i++) {
        work[i] = available[i];
    }

    int finish_count = 0;
    int safe_sequence[N];
    int index = 0;

    while (finish_count < N) {
        bool found = false;
        for (int i = 0; i < N; i++) {
            if (!finish[i] && check(i)) {
                found = true;
                finish[i] = true;
                safe_sequence[index++] = i;
                finish_count++;
                for (int j = 0; j < M; j++) {
                    work[j] += allocation[i][j];
                }
            }
        }
        if (!found) {
            return false;
        }
    }
    printf("分配成功，安全序列为：\n");
    for (int i = 0; i < N; i++) {
        printf("%d ", safe_sequence[i]);
    }
    printf("\n");
    return true;
}

bool request_resources(int pid, int request[]) {
    for (int i = 0; i < M; i++) {
        if (request[i] > need[pid][i]) {
            printf("分配不成功，请求资源数大于所需资源数\n");
            return false;
        }
        if (request[i] > available[i]) {
            printf("分配不成功，请求资源数大于可用资源数\n");
            return false;
        }
    }

    for (int i = 0; i < M; i++) {
        available[i] -= request[i];
        allocation[pid][i] += request[i];
        need[pid][i] -= request[i];
    }

    if (safe_check()) {
        return true;
    } else {
        for (int i = 0; i < M; i++) {
            available[i] += request[i];
            allocation[pid][i] -= request[i];
            need[pid][i] += request[i];
        }
        printf("预分配成功，但不安全，分配不成功\n");
        return false;
    }
}

int main() {
    safe_check();

    int pid;
    printf("请输入需要请求资源的进程编号（0-4）：");
    scanf("%d", &pid);

    int request[M];
    printf("请输入请求的资源数：");
    scanf("%d%d%d%d", &request[0], &request[1], &request[2], &request[3]);

    request_resources(pid, request);

    return 0;
}

在上述代码中，我们首先定义了五个进程和四个资源的数量，并初始化了可用资源数、最大需求矩阵、已分配矩阵、需求矩阵等数据。其中，`safe_check()`函数用于检查系统是否处于安全状态，如果是，就输出安全序列；否则，就返回`false`。`request_resources()`函数用于模拟进程请求资源的过程，如果请求成功，就返回`true`；否则，就返回`false`。最后，在`main()`函数中，我们先调用`safe_check()`函数检查系统是否处于安全状态，然后模拟一个进程请求资源的过程。

需要注意的是，在银行家算法中，我们需要用到两个数组：`need`和`work`。其中，`need[i][j]`表示进程i需要资源j的数量，而`work[j]`表示系统当前可用资源j的数量。在进行安全性检查时，我们需要根据这两个数组来检查是否存在一个安全序列，以保证系统处于安全状态。在模拟进程请求资源的过程中，我们需要更新这两个数组。如果请求成功，就更新`available`、`allocation`和`need`数组；否则，就不更新这些数组。

### 回答2：
银行家算法是一种用于避免死锁的资源分配算法，保证系统在资源分配过程中不会陷入死锁状态。根据题目要求，有五个进程和四个资源，我们可以假设各个进程对资源的需求和已占用的资源数量。

首先，定义进程和资源的数量：

#define PROCESSES 5
#define RESOURCES 4

然后，定义进程的最大需求和已占用资源数量：

int max[PROCESSES][RESOURCES] = {
    {3, 2, 1, 1},
    {1, 1, 2, 1},
    {1, 3, 1, 3},
    {2, 1, 2, 2},
    {1, 2, 2, 1}
};

int allocation[PROCESSES][RESOURCES] = {
    {0, 0, 1, 0},
    {1, 0, 1, 2},
    {1, 0, 3, 3},
    {2, 1, 1, 1},
    {0, 2, 0, 1}
};

接着，定义可用资源数量和工作数组：

int available[RESOURCES] = {1, 0, 0, 1};
int work[RESOURCES];

然后，定义一个标记数组用于判断一个进程是否可以分配资源：

int finish[PROCESSES] = {0, 0, 0, 0, 0};

然后，实现银行家算法：

int flag = 0;  // 标记是否存在可分配资源的进程

for (int i = 0; i < RESOURCES; i++) {
    work[i] = available[i];
}

for (int i = 0; i < PROCESSES; i++) {
    if (finish[i] == 0) {
        int j;
        for (j = 0; j < RESOURCES; j++) {
            if (max[i][j] - allocation[i][j] > work[j])
                break;
        }
        if (j == RESOURCES) {
            for (int k = 0; k < RESOURCES; k++) {
                work[k] += allocation[i][k];
            }
            finish[i] = 1;
            flag = 1;
        }
    }
}

if (flag == 1) {
    printf("分配成功，安全序列为：");
    for (int i = 0; i < PROCESSES; i++) {
        if (finish[i] == 1) {
            printf("%d", i);
            if (i != PROCESSES - 1)
                printf(" -> ");
        }
    }
} else {
    printf("分配不成功");
}

最后，进行安全性检查：

// 预分配成功但安全性检查未通过，所以分配不成功
for (int i = 0; i < PROCESSES; i++) {
    if (finish[i] == 0) {
        printf("预分配成功但安全性检查未通过，所以分配不成功");
        break;
    }
}

以上是一个基于C语言编写的简单银行家算法示例，根据不同的输入数据，可以得到不同的输出结果。