检测关系的性质#c

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

//集合结构体
typedef struct {
    int data[MAX_SIZE];
    int size;
} Jihe;

//关系元组
typedef struct {
    int x;
    int y;
} Yuanzu;

// 定义关系结构体
typedef struct {
    Yuanzu data[MAX_SIZE];
    int size;
} Guanxi;

//集合初始化集合
void JHCSHJH(Jihe *s) {
    s->size = 0;
}



//关系初始化

void GXCSH(Guanxi *r) {
    r->size = 0;
    
}

//判断元素是否在集合中

int isinJihe(Jihe s, int x) {
    for (int i = 0; i < s.size; i++) {
        if (s.data[i] == x) {
            return 1;
        }
    }
    return 0;
}


// 添加一个元素到集合中
void addtoJihe(Jihe *s, int x) {
    if (!isinJihe(*s, x)) {
        s->data[s->size++] = x;
    }
}

//查看元组是否在关系中
int isinyuanzu(Guanxi r, Yuanzu t) {
    for (int i = 0; i < r.size; i++) {

        if (r.data[i].x == t.x && r.data[i].y == t.y) {
            return 1;
        }
    }
    return 0;
}


// 添加一个元组到关系中
void addyuanzu(Guanxi *r, Yuanzu t) {
    if (!isinyuanzu(*r, t)) {

        r->data[r->size++] = t;
    }
}

// 检测关系是否为自反关系

int zfgx(Guanxi r, Jihe s) {
    for (int i = 0; i < s.size; i++) {
        //{<a,a>..........}
        Yuanzu t = {s.data[i], s.data[i]};
        if (!isinyuanzu(r, t)) {
            return 0;
        }
    }
    return 1;
}


// 检测关系是否为对称关系
int dcgx(Guanxi r) {
    for (int i = 0; i < r.size; i++) {
        Yuanzu t = {r.data[i].y, r.data[i].x};
        if (!isinyuanzu(r, t)) {
            return 0;
        }
    }
    return 1;
}


// 检测关系是否为反对称关系
int undcgx(Guanxi r) {
    for (int i = 0; i < r.size; i++) {
        if (r.data[i].x != r.data[i].y) {
            Yuanzu t = {r.data[i].y, r.data[i].x};
            if (isinyuanzu(r, t)) {
                return 0;
            }
        }
    }
    return 1;
}


// 检测关系是否为传递关系
int cdgx(Guanxi r) {
    for (int i = 0; i < r.size; i++) {

            for (int j = 0; j < r.size; j++) {
            if (r.data[i].y == r.data[j].x) {
                Yuanzu t = {r.data[i].x, r.data[j].y};
                if (!isinyuanzu(r, t)) {
                    return 0;
                }
            }
        }

    }
    return 1;
}


int main() {

    // 定义集合和关系
    Jihe s;
    Guanxi r;

    // 初始化集合和关系
    JHCSHJH(&s);
    GXCSH(&r);

    // 输入集合元素个数并添加到集合中
    int n;
    printf("请输入集合元素个数：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        int x;
        printf("请输入第 %d 个元素：", i + 1);
        scanf("%d", &x);
        addtoJihe(&s, x);
    }

    // 输入关系元素个数并添加到关系中
    printf("请输入关系元素个数：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        Yuanzu t;
        printf("请输入第 %d 个元组：", i + 1);
        scanf("%d %d", &t.x, &t.y);
        addyuanzu(&r, t);
    }

    // 检测关系性质并输出结果
    if (zfgx(r, s)) {
        printf("关系是自反的\n");

    } else {
        printf("不是自反关系\n");
    }
    if (dcgx(r)) {
        printf("关系是对称的\n");
        
    } else {
        printf("不是对称关系\n");
    }

    if (undcgx(r)) {
        printf("关系是反对称的\n");
    } else {
        printf("不是反对称关系\n");
    }

    if (cdgx(r)) {
        printf("关系是传递的\n");
    } else {
        printf("不是传递关系\n");
    }

    return 0;
}


//-----------------检测关系的性质------------

//{a,b,c}
//自反{<a,a>...都存在}
//反自反{<a,a>...都不存在}
//既是对称也是反对此{<a,a>....}存在都相同
//对称{<a,b>,<a,b>}不需要全部存在，但存在元素必须对称
//反对称{<a,b>,}不需要全部存在，但是必须不对称
//既不也不{<a,b>,<b,a>,<a,c>}
//传递{<x,y>,<y,z>}-->x,z
///1 0 --> 0非
//蕴含
检测关系的性质#c

0 评论
