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

#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);
}