集合运算（实验题2.6）

集合运算。求集合的并，交和差运算。用有序单链表表示。

#pragma once

//
//aggregate.h
//集合运算；有序单链表实现
//2013-9-4 23:41
//

typedef int element;
typedef struct LNode
{
	element data;
	LNode* next;
}LinkList;

void DisplayLinklist(LinkList* pNode);

void InitSqList( LinkList* & pNode);

int InsertLinklist(LinkList* &pNode,int i,element data);

int Length(LinkList* pNode);

void CreateListR(LinkList* & L,element a[],int length);

void Sort_bubble(LinkList* & L);

void Sort_insert(LinkList* & L);

void Union(LinkList* ha,LinkList* hb,LinkList* &hc);

void InterSect(LinkList* ha,LinkList* hb,LinkList* &hc);

void Subs(LinkList* ha,LinkList* hb,LinkList* &hc);

 

//aggregate.cpp

#include <stdio.h>
#include <malloc.h>
#include "aggregate.h"


void InitSqList( LinkList* & pNode )
{
	pNode = (LinkList*)malloc(sizeof(pNode));
	pNode->next = NULL;
}

int InsertLinklist( LinkList* &pNode,int i,element data )
{
	LinkList* pTemp = pNode;
	int j = 0;
	while ( j < i-1 && pTemp != NULL)
	{
		j ++;
		pTemp = pTemp->next;
	}

	if ( pTemp == NULL)
	{
		return 0;
	}
	LinkList* p = (LinkList*)malloc(sizeof(LinkList));
	p->data = data;
	p->next = pTemp->next;
	pTemp->next = p;

	return 1;
}

void DisplayLinklist( LinkList* pNode )
{
	LinkList* pTemp = pNode->next;
	while(pTemp != NULL)
	{
		printf("%d,",pTemp->data);
		pTemp = pTemp->next;
	}
	printf("\n");
}


int Length( LinkList* pNode )
{
	int length = 0;
	LinkList* p = pNode->next;
	while ( p!= NULL)
	{
		p = p->next;
		length ++;
	}
	return length;
}

//尾插法建表
void CreateListR( LinkList* & L,element a[],int length )
{
	InitSqList(L);
	for ( int i = 1; i <= length; i ++)
	{
		InsertLinklist(L,i,a[i-1]);
	}
}

//表排序，使用冒泡排序
//看了教材上的算法，真不知道当初自己是怎么想出冒泡算法的！汗
//2013-9-9
void Sort_bubble( LinkList* & L )
{
	if ( Length(L) <2)
	{
		return;
	}
	
	LinkList* p = L;
	while (p->next != NULL)
	{
		//printf("%d,",p->next->data);
		LinkList* q = p->next;
		LinkList* s = q->next;
		while ( s!=NULL)
		{
			if (q->data > s->data) //交换p和s
			{
				p->next = s;
				q->next = s->next;
				s->next = q;
			}
			q = s;
			s = s->next;
		}
		p = p->next;
	}
}

//教材提供的排序算法，应该是插入排序
//2013-9-9 23:39
void Sort_insert(LinkList* &L)
{
	LinkList* head = L;
	if ( Length(L) < 2)
	{
		return;
	}
	//p是要插入的节点
	LinkList* p = head->next->next;
	
	head->next->next = NULL;
	while(p != NULL)
	{
		LinkList* q = p->next; //记录q的下一个节点
		while ( head->next != NULL && head->next->data < p->data)
		{
			head = head->next;
		}
		
		p->next = head->next;
		head->next = p;

		head = L;
		p = q;
	}
}

//求两个有序集合并 
//2013-9-10 22:38
void Union( LinkList* ha,LinkList* hb,LinkList* &hc )
{
	InitSqList(hc);
	
	//ha hb 两个需要比较的节点
	LinkList* pa = ha->next, *pb = hb->next;
	//pc标记hc
	LinkList* pc = hc;
	//每次创建的节点
	LinkList*s;

	while ( pa != NULL && pb != NULL)
	{
		s = (LinkList*)malloc(sizeof(LinkList));
		pc->next = s;
		s->next = NULL;
		pc = s;

		if ( pa->data < pb->data)
		{
			s->data = pa->data;
			
			pa = pa->next;
		}
		else if ( pa->data > pb->data)
		{
			s->data = pb->data;
			pb = pb->next;
		}
		else
		{
			s->data = pa->data;
			pa = pa->next;
			pb = pb->next;
		}
	}

	//复制余下的节点
	if ( NULL == pa)
	{
		pa = pb;
	}
	while ( pa != NULL)
	{
		s = (LinkList*)malloc(sizeof(LinkList));
		pc->next = s;
		s->next = NULL;
		pc = s;
		s->data = pa->data;

		pa = pa->next;
	}
}

//求两个集合的交集
//2013-9-10 23:20
void InterSect( LinkList* ha,LinkList* hb,LinkList* &hc )
{
	InitSqList(hc);

	//ha hb 两个需要比较的节点
	LinkList* pa = ha->next, *pb = hb->next;
	//pc标记hc
	LinkList* pc = hc;
	//每次创建的节点
	LinkList*s;

	while ( pa != NULL && pb != NULL)
	{
		if ( pa->data < pb->data)
		{
			pa = pa->next;
		}
		else if ( pa->data > pb->data)
		{
			pb = pb->next;
		}
		else
		{
			s = (LinkList*)malloc(sizeof(LinkList));
			pc->next = s;
			s->next = NULL;
			pc = s;
			s->data = pa->data;
			pa = pa->next;
			pb = pb->next;
		}
	}
}

//求两个有序集合的差
//2013-9-10 23:35
void Subs( LinkList* ha,LinkList* hb,LinkList* &hc )
{
	InitSqList(hc);

	//ha hb 两个需要比较的节点
	LinkList* pa = ha->next, *pb = hb->next;
	//pc标记hc
	LinkList* pc = hc;
	//每次创建的节点
	LinkList*s;

	while ( pa != NULL && pb != NULL)
	{
		if ( pa->data < pb->data)
		{
			s = (LinkList*)malloc(sizeof(LinkList));
			pc->next = s;
			s->next = NULL;
			pc = s;
			s->data = pa->data;

			pa = pa->next;
		}
		else if ( pa->data > pb->data)
		{
			pb = pb->next;
		}
		else
		{
			pa = pa->next;
			pb = pb->next;
		}
	}

	//复制余下的节点
	if ( NULL == pb)
	{
		while ( pa != NULL)
		{
			s = (LinkList*)malloc(sizeof(LinkList));
			pc->next = s;
			s->next = NULL;
			pc = s;
			s->data = pa->data;

			pa = pa->next;
		}
	}
}

 

#include <stdio.h>
#include "aggregate.h"

int main()
{
	LinkList* ha;
	element a[]= {2,1,5};
	CreateListR(ha,a,3);
	//DisplayLinklist(ha);
	//printf("%d,",Length(ha));
	//Sort(ha);
	Sort_insert(ha);
	DisplayLinklist(ha);

	LinkList* hb;
	element b[]= {3,1,2,4};
	CreateListR(hb,b,4);
	//DisplayLinklist(hb);
	//printf("%d,",Length(ha));
	//Sort(ha);
	Sort_insert(hb);
	DisplayLinklist(hb);

	LinkList* hc;
	Subs(hb,ha,hc);
	DisplayLinklist(hc);
	return 0;
}