C语言实现闭包、自反闭包、对称闭包和传递闭包

好的，以下是一个简单的C语言代码，可以根据用户输入的选项来计算闭包、自反闭包、对称闭包和传递闭包。

#include <stdio.h>
#define MAX 100

int R[MAX][MAX], S[MAX][MAX], T[MAX][MAX]; // 定义全局变量，三个二维数组分别存储关系R、S、T

// 计算自反闭包
void reflexive_closure(int n) {
    for (int i = 1; i <= n; i++) {
        R[i][i] = 1; // 对角线上的元素为1
    }
}

// 计算对称闭包
void symmetric_closure(int n) {
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (R[i][j] == 1) { // 如果R[i][j]为1，则S[j][i]也为1
                S[j][i] = 1;
            }
            if (R[j][i] == 1) { // 如果R[j][i]为1，则S[i][j]也为1
                S[i][j] = 1;
            }
        }
    }
}

// 计算传递闭包
void transitive_closure(int n) {
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                T[i][j] = T[i][j] || (T[i][k] && T[k][j]); // 如果T[i][k]和T[k][j]都为1，则T[i][j]也为1
            }
        }
    }
}

// 计算R的闭包
void closure(int n) {
    int flag = 1; // 标识闭包是否已经计算完毕
    while (flag) {
        flag = 0; // 假设闭包已经计算完毕
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (R[i][j] == 1) { // 如果R[i][j]为1，则更新R的闭包
                    for (int k = 1; k <= n; k++) {
                        if (R[j][k] == 1 && R[i][k] == 0) { // 如果R[j][k]为1且R[i][k]为0，则更新R[i][k]为1
                            R[i][k] = 1;
                            flag = 1; // 如果更新了R[i][k]，说明闭包还没有计算完毕
                        }
                    }
                }
            }
        }
    }
}

int main() {
    int n; // 关系矩阵的大小
    printf("请输入关系矩阵的大小：");
    scanf("%d", &n);
    printf("请输入关系矩阵的元素(0或1):\n");
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            scanf("%d", &R[i][j]); // 输入关系矩阵
            S[i][j] = R[i][j]; // S的初始值就是R
            T[i][j] = R[i][j]; // T的初始值就是R
        }
    }
    printf("请选择要计算的闭包类型：\n");
    printf("1. 闭包\n");
    printf("2. 自反闭包\n");
    printf("3. 对称闭包\n");
    printf("4. 传递闭包\n");
    int choice;
    scanf("%d", &choice); // 用户选择要计算的闭包类型
    switch (choice) {
        case 1:
            closure(n); // 计算闭包
            printf("闭包为：\n");
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    printf("%d ", R[i][j]); // 输出闭包
                }
                printf("\n");
            }
            break;
        case 2:
            reflexive_closure(n); // 计算自反闭包
            printf("自反闭包为：\n");
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    printf("%d ", R[i][j]); // 输出自反闭包
                }
                printf("\n");
            }
            break;
        case 3:
            symmetric_closure(n); // 计算对称闭包
            printf("对称闭包为：\n");
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    printf("%d ", S[i][j]); // 输出对称闭包
                }
                printf("\n");
            }
            break;
        case 4:
            transitive_closure(n); // 计算传递闭包
            printf("传递闭包为：\n");
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    printf("%d ", T[i][j]); // 输出传递闭包
                }
                printf("\n");
            }
            break;
        default:
            printf("输入错误！\n"); // 输入错误的处理
            break;
    }
    return 0;
}

这个代码中，我们先定义了三个二维数组R、S、T，分别存储关系R、S、T的元素值。然后通过调用四个函数 closure()、reflexive_closure()、symmetric_closure() 和 transitive_closure() 分别计算闭包、自反闭包、对称闭包和传递闭包。在主函数中，我们先输入关系矩阵的大小和元素值，然后让用户选择要计算的闭包类型，最后输出对应的闭包结果。其中，计算闭包的函数 closure() 使用了一个 while 循环来不断更新R的闭包，直到闭包已经计算完毕为止。