【离散数学】集合上二元关系性质判定的实现（c语言实现）

鸽鸽程序猿

已于 2024-07-23 21:41:00 修改

阅读量376

点赞数 22

分类专栏： c语言文章标签： c语言

于 2024-05-08 15:35:08 首次发布

本文链接：https://blog.csdn.net/yj20040627/article/details/138572796

版权

c语言专栏收录该内容

13 篇文章 18 订阅

订阅专栏

实验

实验内容

对任意二元关系集合，判定其是否具有自反性、对称性、传递性、反对称性、反自反性，如果不具有某性质，需输出至少一个反例。

实验要求

要求：

输入：集合X的元素个数（不超过5个元素，必做)；
X上关系的序偶个数（选做）输出关系矩阵（由程序随机生成）
输出性质描述，不具备的性质需给出反例描

在这里插入图片描述

输出样例

输出样例如下图：

[外链图片转存中…(img-T6pl6erM-1719884717385)]

具体实现

具体实现可以参考如下方式。

关系矩阵的初始化和打印

我们将关系矩阵存入一个二维数组中，因为集合元素个数不会超过5个，所以就用一个5行5列二维数组来表示。

在我们得到了集合元素个数之后我们就可以对数组进行0,1随机赋值

//初始关系矩阵
void init_matrix(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			array[i][j] = rand() % 2;
		}
	}
}

//打印矩阵
void print_matrix(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			printf("%d ", array[i][j]);
		}
		printf("\n");
	}
}

验证自反性

自反性的验证就是主对角线上元素是不是全为1，直接使用循环判断就行。

//验证自反性
void judge_introspect(int array[][5], int n)
{
	n--;
	while (n >= 0)
	{
		if (array[n][n] != 1)
		{
			printf("不满足自反性，因为第%d行第%d列应该为1\n", n+1, n+1);
			return;
		}	
		n--;
	}
	printf("满足自反性\n");
}

验证反自反性

反自反性的验证就是主对角线上元素只要有一个不是1那就满足反自反性，同样使用循环直接判断就行。

//验证反自反性
void judge_irreflexive(int array[][5], int n)
{
	n--;
	while (n >= 0)
	{
		if (array[n][n] != 0)
		{
			printf("不满足反自反性，因为第%d行第%d列应该为0\n", n+1, n+1);
			return;
		}
		n--;
	}
	printf("满足反自反性\n");
}

验证对称性

对称性就是关于主对角线对称相等，同样使用循环直接判断就行。

//验证对称性
void judge_symmetry(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] != array[j][i])
			{
				printf("不满足对称性，因为第%d行第%d列和第%d行第%d列不同时为%d\n", i+1, j+1, j+1, i+1, array[i][j]);
				return;
			}
		}
	}
	printf("满足对称性\n");
}

验证反对称性

反对称性就是如果两个元素相等，那么它一定是行列相等的元素。

//验证反对称性
void judge_antisymmetry(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] == array[j][i] && i != j)
			{
				printf("不满足反对称性，因为第%d行第%d列和第%d行第%d列同时为%d\n", i+1, j+1, j+1, i+1, array[i][j]);
				return;
			}
		}
	}
	printf("满足反对称性\n");
}

验证传递性

就是arr[a][b] == 1并且arr[a][c] == 1并且arr[c][b] == 1。

我在这用了三个循环来判断，是最笨的方法，如果有好办法请给在评论区分享一下。

//验证传递性
void judge_transfer(int array[][5], int n)
{
	int flag = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] == 1 && i !=j)
			{
				for(int m = 0; m < n; m++)
				{
					if (((array[i][m] == 1 && array[m][j] != 1) || 
						(array[i][m] == 1 && array[m][j] != 1))
						&& m != i && m != j)
					{
						printf("不满足传递性因为第%d行第%d列为%d，第%d行第%d列为%d，第%d行第%d列也为%d\n",
							i + 1, m + 1, array[i][m], m + 1, j + 1, array[m][j], i + 1, j + 1, array[i][j]);
						
						flag++;
						break;
					}
				}
			}
		}
	}
	if (flag == 0)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (array[i][j] == 1 && i != j)
				{
					int m = 0;
					while (1)
					{
						m = rand() % n;
						if (m != i && m != j)
						{
							break;
						}
					}
					printf("满足传递性因为第%d行第%d列为1，第%d行第%d列为1，第%d行第%d列也为1\n", i + 1, m + 1, m + 1, j + 1, i + 1, j + 1);
				}
			}
		}
	}
}

源码

源码呈上：

# define _CRT_SECURE_NO_WARNINGS 1；
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

//初始关系矩阵
void init_matrix(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			array[i][j] = rand() % 2;
		}
	}
}

//打印矩阵
void print_matrix(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			printf("%d ", array[i][j]);
		}
		printf("\n");
	}
}
//验证自反性
void judge_introspect(int array[][5], int n)
{
	n--;
	while (n >= 0)
	{
		if (array[n][n] != 1)
		{
			printf("不满足自反性，因为第%d行第%d列应该为1\n", n+1, n+1);
			return;
		}	
		n--;
	}
	printf("满足自反性\n");
}
//验证反自反性
void judge_irreflexive(int array[][5], int n)
{
	n--;
	while (n >= 0)
	{
		if (array[n][n] != 0)
		{
			printf("不满足反自反性，因为第%d行第%d列应该为0\n", n+1, n+1);
			return;
		}
		n--;
	}
	printf("满足反自反性\n");
}
//验证对称性
void judge_symmetry(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] != array[j][i])
			{
				printf("不满足对称性，因为第%d行第%d列和第%d行第%d列不同时为%d\n", i+1, j+1, j+1, i+1, array[i][j]);
				return;
			}
		}
	}
	printf("满足对称性\n");
}
//验证反对称性
void judge_antisymmetry(int array[][5], int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] == array[j][i] && i != j)
			{
				printf("不满足反对称性，因为第%d行第%d列和第%d行第%d列同时为%d\n", i+1, j+1, j+1, i+1, array[i][j]);
				return;
			}
		}
	}
	printf("满足反对称性\n");
}
//验证传递性
void judge_transfer(int array[][5], int n)
{
	int flag = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] == 1 && i !=j)
			{
				for(int m = 0; m < n; m++)
				{
					if (((array[i][m] == 1 && array[m][j] != 1) || 
						(array[i][m] == 1 && array[m][j] != 1))
						&& m != i && m != j)
					{
						printf("不满足传递性因为第%d行第%d列为%d，第%d行第%d列为%d，第%d行第%d列也为%d\n",
							i + 1, m + 1, array[i][m], m + 1, j + 1, array[m][j], i + 1, j + 1, array[i][j]);
						
						flag++;
						break;
					}
				}
			}
		}
	}
	if (flag == 0)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (array[i][j] == 1 && i != j)
				{
					int m = 0;
					while (1)
					{
						m = rand() % n;
						if (m != i && m != j)
						{
							break;
						}
					}
					printf("满足传递性因为第%d行第%d列为1，第%d行第%d列为1，第%d行第%d列也为1\n", i + 1, m + 1, m + 1, j + 1, i + 1, j + 1);
				}
			}
		}
	}
}
int main()
{
	srand((unsigned int)time(NULL));
	//用随机数生成集合数
	int num = rand() % 5 + 1;
	int relationMatrix[5][5] = { 0 };//关系矩阵
	init_matrix(relationMatrix, num);//初始关系矩阵
	print_matrix(relationMatrix, num);//打印矩阵
	judge_introspect(relationMatrix, num);//验证自反性
	judge_irreflexive(relationMatrix, num);//验证反自反性
	judge_symmetry(relationMatrix, num);//验证对称性
	judge_antisymmetry(relationMatrix, num);//验证反对称性
	judge_transfer(relationMatrix, num);//验证传递性
	return 0;
}