二元关系的表示与基本运算

最新推荐文章于 2025-06-17 13:43:43 发布

原创最新推荐文章于 2025-06-17 13:43:43 发布 · 3.4k 阅读

5 ·

CC 4.0 BY-SA版权

【Discrete Mathematics】专栏收录该内容

25 篇文章

订阅专栏

#ifndef _BINARYRELATIONHEADER_H_
#define _BINARYRELATIONHEADER_H_

#define MAX_SIZE 10

typedef struct LinkSet
{
	char ele[MAX_SIZE];
	struct LinkSet* next;
}LinkSet;


static int LinkSetInit(LinkSet** head);
static int LinkSetPrint(const LinkSet* set);
static int LinkSetPush(LinkSet* set, const char* data);
static int LinkSetPop(LinkSet* set, char* data);
static int LinksetModify(LinkSet* set, char* olddata, char* newdata);
static int LinkSetDestroy(LinkSet** set);

static int ToBinaryRelationSet(const char* s, LinkSet* set);
static int ToBinaryRelationMatrix(const char* s, int matrix[10][10], int* m_size);

static void BinaryRelationSetPrint(LinkSet* set);
static void BinaryRelationMatrixPrint(int matrix[MAX_SIZE][MAX_SIZE], int m_size);
static void BinaryRelationCompOper(LinkSet* bina_set1, LinkSet* bina_set2, LinkSet* resu);
static void BinaryRelationinveOper(LinkSet* bina_set1, LinkSet* resu);
static void RelfeClosuOper(LinkSet* bina_set1, LinkSet* resu);
static void SymColsuOper(LinkSet* bina_set1, LinkSet* resu);

static void trans_colsu_oper(int matrix[10][10], int resu_m[10][10], int m_size);
static void matrix2set(int matrix[10][10], int size, LinkSet* resu);

void BinaryRelationTest();


#endif // end of _BINARYRELATIONHEADER_H_

#include "BinaryRelationHeader.h"

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


int LinkSetInit(LinkSet** head)
{
	if((*head = (LinkSet*)malloc(sizeof(LinkSet))) == NULL)
	{
		return 0;
	}

	(*head)->next = NULL;
	strcpy((*head)->ele, "\0");

	return 1;
}

int LinkSetPrint(const LinkSet* set)
{
	printf("{");
	while(set->next != NULL)
	{
		printf("%s   ", set->next->ele);
		set = set->next;
	}
	printf("}\n");
	return 0;
}

int LinkSetPush(LinkSet* set, const char* data)
{
	assert(set != NULL);

	while(set != NULL)
	{
		if(strcmp(set->ele, data) == 0)
			return 0;
		else if(set->next == NULL)
		{
			LinkSet* node = (LinkSet*)malloc(sizeof(LinkSet));
			set->next = node;
			node->next = NULL;
			strcpy(node->ele, data);
			return 1;
			
		}
		else
		{
			int l1 = strlen(data), l2 = strlen(set->next->ele);
			if(l1 < l2 || (l1 == l2 && strncmp(data, set->next->ele, l1) < 0))
			{	
				LinkSet* node = (LinkSet*)malloc(sizeof(LinkSet));
				node->next = set->next;
				set->next = node;
				strcpy(node->ele, data);
				return 1;
			}
		}
		set = set->next;
	}
	return 0;
}

int LinkSetPop(LinkSet* set, char* data)
{
	assert(set != NULL);

	while(set->next != NULL)
	{
		if(strcmp(set->next->ele, data) == 0)
		{
			LinkSet* tmp = set->next;
			set->next = tmp->next;
			free(tmp);
			return 1;
		}
		set = set->next;
	}
	return 0;
}

int LinkSetModify(LinkSet* set, char* olddata, char* newdata)
{
	while(set != NULL)
	{
		if(strcmp(set->ele, olddata) == 0)
		{
			strcpy(set->ele, newdata);
			return 1;
		}
		set = set->next;
	}
	return 0;
}

int LinkSetDestroy(LinkSet** set)
{
	while((*set)->next != NULL)
	{
		LinkSet* tmp = *set;
		(*set) = (*set)->next;
		free(tmp);
	}
	return 0;
}



//Binary Ralation set
int ToBinaryRelationSet(const char* s, LinkSet* set)
{
	int i = 0, j = 0;
	char ss[100];
	memset(ss, '\0', sizeof(char) * 100);
	while(s[i] != '#')
	{
		if(s[i] != ' ')
		{
			ss[j++] = s[i];
			i++;
		}
		else
		{
			LinkSetPush(set, ss);
			j = 0;
			memset(ss, '\0', sizeof(char) * 100);
			while(s[i] == ' '){ i++; }
		}
	}
	return 1;
}

//二元关系矩阵表示
int ToBinaryRelationMatrix(const char* s, int matrix[10][10], int* m_size)
{//为方便演示数组不超过10
	int i = 0;
	while(s[i] != '#')
	{//遇到字符'<'则将后面数字转化¥常数加入矩阵同时得到最大的数作为数组最大值
		if(s[i] == '<')
		{
			int j = (int)(s[i + 1] - '0'),
				k = (int)(s[i + 3] - '0');

			*m_size = *m_size > (j > k ? j : k) ? *m_size : (j > k ? j : k);

			matrix[j][k] = 1;
			i += 4;
		}
		i++;
	}
	return 1;
}

//打印二元关系集合
void BinaryRelationSetPrint(LinkSet* set)
{
	LinkSetPrint(set);
}


void BinaryRelationMatrixPrint(int matrix[MAX_SIZE][MAX_SIZE], int m_size)
{
	int i = 0, j = 0;
	printf("   ");
	for(j = 1; j <= m_size; j++)
		printf("%d ", j);
	printf("\n");

	for(i = 1; i <= m_size; i++)
	{
		printf("%d  ", i);
		for(j = 1; j <= m_size; j++)
		{
			printf("%d ", matrix[i][j]);
		}
		printf("\n");
	}
}

void BinaryRelationCompOper(LinkSet* bina_set1, LinkSet* bina_set2, LinkSet* resu)
{//遍历集合和集合，找到集合二元关系Ì'>'前数字和集合'<'后数字，若相同则复合
	LinkSet* tmp2;
	char s[100];
	while(bina_set1->next != NULL)
	{
		tmp2 = bina_set2;
		while(tmp2->next != NULL)
		{
			if(bina_set1->next->ele[3] == tmp2->next->ele[1])
			{
				memset(s, '\0', sizeof(char) * 100);
				s[0] = '<'; s[1] = bina_set1->next->ele[1];
				s[2] = ','; s[3] = tmp2->next->ele[3];
				s[4] = '>';
				LinkSetPush(resu, s);
			}
			tmp2 = tmp2->next;
		}
		bina_set1 = bina_set1->next;
	}
}

void BinaryRelationinveOper(LinkSet* bina_set1, LinkSet* resu)
{
	char s[10];
	while(bina_set1->next != NULL)
	{
		memset(s, '\0', sizeof(char) * 10);
		s[0] = '<'; s[1] = bina_set1->next->ele[3];
		s[2] = ','; s[3] = bina_set1->next->ele[1];
		s[4] = '>';
		LinkSetPush(resu, s);

		bina_set1 = bina_set1->next;
	}
}

//自反闭包
void RelfeClosuOper(LinkSet* bina_set1, LinkSet* resu)
{
	char s[10];
	while(bina_set1->next != NULL)
	{
		LinkSetPush(resu, bina_set1->next->ele);

		memset(s, '\0', sizeof(char) * 10);
		s[0] = '<'; s[1] = bina_set1->next->ele[1];
		s[2] = ','; s[3] = bina_set1->next->ele[1];
		s[4] = '>';
		LinkSetPush(resu, s);

		memset(s, '\0', sizeof(char) * 10);
		s[0] = '<'; s[1] = bina_set1->next->ele[3];
		s[2] = ','; s[3] = bina_set1->next->ele[3];
		s[4] = '>';
		LinkSetPush(resu, s);

		bina_set1 = bina_set1->next;
	}
}

void SymColsuOper(LinkSet* bina_set1, LinkSet* resu)
{
	char s[10];
	while(bina_set1->next != NULL)
	{
		LinkSetPush(resu, bina_set1->next->ele);

		if(bina_set1->next->ele[1] == bina_set1->next->ele[3])
		{
			bina_set1 = bina_set1->next;
			continue;
		}

		memset(s, '\0', sizeof(char) * 10);
		s[0] = '<'; s[1] = bina_set1->next->ele[3];
		s[2] = ','; s[3] = bina_set1->next->ele[1];
		s[4] = '>';
		LinkSetPush(resu, s);


		bina_set1 = bina_set1->next;
	}
}

void trans_colsu_oper(int matrix[10][10], int resu_m[10][10], int m_size)
{
	int i, j, k;

	int  t[10][10] = {0};

	for(i = 1; i <= m_size; i++)
		for(j = 1; j <= m_size; j++)
			if(i == j || matrix[i][j] == 1)
				t[i][j] = 1;
			else
				t[i][j] = 0;
	
	for(k = 1; k <= m_size; k++)
	{
		for(i = 1; i <= m_size; i++)
			for(j = 1; j <= m_size; j++)
				t[i][j] = t[i][j] | (t[i][k] & t[k][j]);

		
	}
	memcpy(resu_m, t, sizeof(int) * 10 * 10);
}


void matrix2set(int matrix[10][10], int size, LinkSet* resu)
{
	int i, j;
	char s[10];
	for(i = 1; i <= size; i++)
	{
		for(j = 1; j <= size; j++)
		{
			if(matrix[i][j] == 1)
			{
				memset(s, '\0', sizeof(char) * 10);
				s[0] = '<'; s[1] = (char)(i + '0');
				s[2] = ','; s[3] = (char)(j + '0');
				s[4] = '>';
				LinkSetPush(resu, s);
			}
		}
	}
}

void BinaryRelationTest()
{
	char s1[1000] = {"<1,1> <2,1> <3,2> <4,4> #"}, s2[1000] = {"<2,3> <1,4> #"}; 
	int matrix1[10][10] = {0}, matrix2[10][10] = {0};
	int m_size1 = 0, m_size2 = 0;
	LinkSet *set1, *set2;
	LinkSet *resu_c, *resu_i, *resu_r, *resu_s, *resu_t;
	int resu_t_matrix[10][10] = {0};

	LinkSetInit(&set1);
	LinkSetInit(&set2);
	LinkSetInit(&resu_c);
	LinkSetInit(&resu_i);
	LinkSetInit(&resu_r);
	LinkSetInit(&resu_s);
	LinkSetInit(&resu_t);

	ToBinaryRelationSet(s1, set1);
	ToBinaryRelationSet(s2, set2);
	ToBinaryRelationMatrix(s1, matrix1, &m_size1);
	ToBinaryRelationMatrix(s2, matrix2, &m_size2);

	printf("binary relation set1 is:\n");
	BinaryRelationSetPrint(set1);
	printf("binary relation matrix1 is:\n");
	BinaryRelationMatrixPrint(matrix1, m_size1);

	printf("binary relation set2 is:\n");
	BinaryRelationSetPrint(set2);
	printf("binary relation matrix2 is:\n");
	BinaryRelationMatrixPrint(matrix2, m_size2);


	BinaryRelationCompOper(set1, set2, resu_c);
	BinaryRelationinveOper(set1, resu_i);
	RelfeClosuOper(set1, resu_r);
	SymColsuOper(set1, resu_s);
	trans_colsu_oper(matrix1, resu_t_matrix, m_size1);


	printf("compound set1 and set2 is:\n");
	LinkSetPrint(resu_c);
	printf("inverse set1 is:\n");
	LinkSetPrint(resu_i);
	printf("reflexive set1 is:\n");
	LinkSetPrint(resu_r);
	printf("symmetry set1 is:\n");
	LinkSetPrint(resu_s);
	printf("transport set1 is:\n");
	matrix2set(resu_t_matrix, m_size1, resu_t);
	LinkSetPrint(resu_t);

	LinkSetDestroy(&resu_r);
	LinkSetDestroy(&resu_i);
	LinkSetDestroy(&resu_t);
	LinkSetDestroy(&resu_s);
	LinkSetDestroy(&resu_c);
	LinkSetDestroy(&set1);
	LinkSetDestroy(&set2);
}