【数据结构】线性表的应用

问题描述

• 问题： 假设有两个表A和B，分别是m1行、n1列和m2行、n2列，它们简单自然连接结果C=AxB（i=j)，其中i表示表A中列号，j表示表B中的列号，C为A和B的笛卡儿积中满足指定连接条件的所有记录组，该连接条件为表A的第i列与表B的第j列相等

• 什么是笛卡尔积？
  设A,B为集合，用A中元素为第一元素，B中元素为第二元素构成有序对，所有这样的有序对组成的集合叫做A与B的笛卡尔积，记作AxB.
  例如，A={a,b}, B={0,1,2}，则
  A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
  B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}
  拿题目当例子就是，不考虑 i=j 就是笛卡尔积
• 也就是C=AxB={ (1,2,3,3,5),(1,2,3,1,6),(1,2,3,3,4),(2,3,3,3,5),(2,3,3,1,6),(2,3,3,3,4),(1,1,1,3,5),(1,1,1,1,6),(1,1,1,3,4) }
• 取C中集合的第3列和第4列相同的元素组成一个大集合
  

数据结构定义

• 由于每个表的行列数都不确定，由连接条件可知要求元素每行可以随机存取，因此采用如下结构

#define MAX_COL 10

typedef struct RowHeadNode
{
	int a[MAX_COL];
	struct RowHeadNode* next;
}RowHeadNode;

typedef struct MaxtriHeadNode
{
	int row, col;
	RowHeadNode* next;
}MaxtriHeadNode;

基本操作算法

//建表
MaxtriHeadNode*  CreateTable()
{
	int row = 0;
	int col = 0;
	MaxtriHeadNode* h = (MaxtriHeadNode*)malloc(sizeof(MaxtriHeadNode));
	h->next = NULL;
	RowHeadNode* r = h ->next;
	printf("Please input the row num: ");
	scanf("%d", &h->row);
	printf("Please input the col num: ");
	scanf("%d", &h->col);
	for (row = 0; row < h->row; row++)
	{
		RowHeadNode* s = (RowHeadNode*)malloc(sizeof(RowHeadNode));
		printf("Please input the %d row,%d data : \n", row + 1,h->col);
		
		for (col = 0; col < h->col; col++)
		{
			scanf("%d", &s->a[col]);
		}
		if (!h->next) h->next = s;
		else r ->next= s;
		r = s;
	}
	r->next = NULL;
	return h;
}

//显示
void DispTable(MaxtriHeadNode* h)
{
	RowHeadNode* p = h->next;
	printf("**********************************\n");
	while (p)
	{
		for (int i = 0; i < h->col; i++)
			printf("\t%d", p->a[i]);
		printf("\n");
		p = p->next;
	}
	printf("**********************************\n");
}
 
// 摧毁
void DestroyTable(MaxtriHeadNode* h)
{
	RowHeadNode* pre = h->next;
	RowHeadNode* p = h->next->next;
	while (p)
	{
		free(pre);
		pre = p;
		p = p->next;
	}
	free(pre);
	free(h);
}

主要流程

MaxtriHeadNode* LinkTable(MaxtriHeadNode* h1, int h1_i,MaxtriHeadNode* h2,int h2_i)
{
	int row = 0;
	int col = h1->col + h2->col;
	RowHeadNode* p1 = h1->next;
	RowHeadNode* p2 = h2->next;
	RowHeadNode* t;
	MaxtriHeadNode* head = (MaxtriHeadNode*)malloc(sizeof(MaxtriHeadNode));
	head->next = NULL;	
	RowHeadNode* r= head->next;
	while (p1)
	{
		while (p2)
		{
			if ((p1->a[h1_i - 1]) == (p2->a[h2_i - 1]))
			{
				t = (RowHeadNode*)malloc(sizeof(RowHeadNode));
				//以下两行存在bug，memcpy时字节数过大；会导致堆被破坏
				//注意检查实际memcpy的空间，过大时容易占用到未分配的空间，然后malloc时会提示堆被破坏；
				//memcpy(t->a, p1->a, h1->col * sizeof(p1->a));
				//memcpy(&t->a[h1->col], p2->a, h2->col * sizeof(p1->a));  
				for (int idata = 0; idata < h1->col; idata++)
					t->a[idata] = p1->a[idata];
				for (int idata = 0; idata < h2->col; idata++)
					t->a[idata+h1->col] = p2->a[idata];
				if (!head->next)  head->next = t;
				else  r->next = t;
				r = t;
				row++;
			}
			p2 = p2->next;
		}
		p2 = h2->next;
		p1 = p1->next;
	}
	r->next = NULL;
	head->col = col;
	head->row = row;
	return head;
}

运行程序

int main()
{
	MaxtriHeadNode* pMaxt1 = CreateTable();
	MaxtriHeadNode* pMaxt2 = CreateTable();
	DispTable(pMaxt1);
	DispTable(pMaxt2);
	pMaxt1=LinkTable(pMaxt1,3, pMaxt2,1);
	DispTable(pMaxt1);
	DestroyTable(pMaxt1);
	DestroyTable(pMaxt2);
	getch();
	return 0;
}

运行结果