.h

#define SEGMENT 50 // 有序线性表元素每段长度

typedef int ElemType; // 定义线性表元素类型为整数 int.

typedef struct{
ElemType *elem; // 元素类型的动态数组指针
int size; // 有序线性表的元素个数，初始值为 0。
int capacity; // 有序线性表内存容量。
} List;

void initial(List *);//初始化线性表，size为0

int getSize(List);//线性表的长度

int getCapacity(List);//取得线性表L的内存容量

ElemType getElem(List,int);//从L中取出位置i的元素e，0≤i＜size，返回e，否则返回-1

int search(List, ElemType);//搜索元素 e 在 L中的位置。若成功，返回 e 的位置；否则，返回 -1

int insert(List *, ElemType); //将元素 e 插入到 L 适当的位置。若成功，返回 e 的位置；否则，返回 -1

int delete(List *, ElemType); //从 L 删除元素 e。若成功，返回 e 原来的位置；否则，返回 -1

void destroy(List *);//将线性表 L销毁，释放线性表的内存空间

void clear(List *);//将线性表 L 清空，将 size设为 0

int is_empty(List); //检查线性表 L是否为空表。若空，返回 1；否则，返回 0

void printlst(List);//打印线性表元素

 

.c

#include <stdio.h>
#include <stdlib.h>
#include "3197103105_set.h"

//初始化线性表，size为0
void initial(List*L)
{
L->elem=(ElemType*)calloc(SEGMENT,sizeof(ElemType));//分配内存空间
L->size==0;//size设为0
L->capacity=SEGMENT;//线性表初始内存容量
}

//取得线性表 L的大小，返回元素个数。
int getSize(List L)
{
return L.size; //线性表 L的长度
}

//取得线性表 L的内存容量。
int getCapacity(List L)
{
return L.capacity;
}

//从L中取出位置i的元素e，0≤i＜size，返回e，否则返回-1
ElemType getElem(List L,int i)
{
if(i>=0&&i<L.size)
return L.elem[i];
else
return -1;
}

//搜索元素 e 在 L中的位置。若成功，返回 e 的位置；否则，返回 -1
int search(List L, ElemType e)
{
int i;

for (i=0;i<L.size;i++)
if(L.elem[i]==e)
return i;
else
return -1;
}

//将元素 e 插入到 L适当的位置。若成功，返回e的位置;否则，返回-1
int insert(List*L, ElemType e)
{
int i,j;
for(i=0;i<L->size;i++)
if(L->elem[i]>=e)break;
for(j=L->size-1;j>=i;j--) L->elem[j+1] = L->elem[j];
L->elem[i] = e;
L->size++;
if (L->size==L->capacity)
{
L->elem = (ElemType *) realloc(L->elem, (L->capacity+SEGMENT)*sizeof(ElemType));
L->capacity += SEGMENT;
}
return i;
}

//从 L 删除元素 e。若成功，返回 e 原来的位置；否则，返回 -1
int delete(List*L,ElemType e)
{
int i,j;
for(i=0;i<L->size;i++)
if(L->elem[i]==e)break;
else if(L->elem[i]>e)
return -1;
//将元素 i 之后的元素往前移一个位置。
for (j=i; j<L->size; j++) L->elem[j] = L->elem[j+1];
L->size--; //更新线性表的元素个数。
//如果线性表的内存容量比元素个数多出两段元素，则将内存容量减少一段元素。
if ((L->capacity-L->size)>=SEGMENT*2)
{
L->elem = (ElemType *) realloc(L->elem,(L->capacity-SEGMENT)*sizeof(ElemType));
L->capacity -= SEGMENT;
}
return i;
}

//将线性表 L销毁，释放线性表的内存空间
void destroy(List*L)
{
free(L->elem);
L->capacity=0;
L->size=0;
}

//将线性表 L清空，将 size设为 0
void clear(List*L)
{
L->elem=(ElemType*)realloc(L->elem,SEGMENT*sizeof(ElemType));
L->size=0;
L->capacity=SEGMENT;
}

//检查线性表 L是否为空表。若空，返回 1；否则，返回 0
int is_empty(List L)
{
return L.size==0;
}

//打印线性表的元素
void printlst(List L)
{
int i;
printf("线性表内存容量：%3d 元素\n", L.capacity);
printf("线性表元素个数：%3d 元素\n", L.size);

for (i=0; i<L.size; i++)
{
printf("%3d ", L.elem[i]);
if ((i+1)%20==0) printf("\n");
}
if ((i%20)!=0) printf("\n");
printf("\n");
}

 

.main.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "3197103105_set.h"

//删除线性表重复元素
void DelTheSame(List L,ElemType e)
{
int i;
int num;
for(i=1;i<L.size;i++)
{
if(L.elem[i-1]!=L.elem[i]) //读取表中第i-1位，与第i位做比较
{
delete(L, ElemType i);//若第i-1位与第i位相同，则删除第i位
num = L.elem[i-1]; //储存第i-1位的值
}
else
{
num = L.elem[i];//储存返回第i位的值
}
return num;
}
}

//并集
List union_list(List L1,List L2)
{
List L;
int size1=getSize(L1),size2=getSize(L2);
ElemType e1,e2;
int i1=0,i2=0;
initial(&L);

while(i1<size1&&i2<size2)
{
e1 = getElem(L1, i1);
e2 = getElem(L2, i2);
if(e1<=e2)
{
insert(&L,e1);i1++;
}
else
{
insert(&L,e2);i2++;
}
while (i1<size1) insert(&L, getElem(L1, i1++));
while (i2<size2) insert(&L, getElem(L2, i2++));
}
return L;
}

//交集
List intersection_list(List L1,List L2)
{
List L;
int size1=getSize(L1),size2=getSize(L2);
ElemType e1,e2;
int i1=0,i2=0;
initial(&L);

while(i1<size1&&i2<size2)
{
e1 = getElem(L1, i1);
e2 = getElem(L2, i2);
if(e1==e2)
{
insert(&L,e1);i1++;//若L1的元素和L2的元素相同，将L1的元素放进L中
}
else if
{
i1++;
i2++;
}

}
return L;
}

//差集
List difference_list(List L1,List L2)
{
List L;
int size1=getSize(L1),size2=getSize(L2);
ElemType e1,e2;
int i1=0,i2=0;
initial(&L);

while(i1<size1&&i2<size2)
{
e1 = getElem(L1, i1);
e2 = getElem(L2, i2);
if(e1==e2)i1++;
else if(e1<e2)
{
insert(&L,e1);i++;
}
else i2++;
}
while (i1<size1) insert(&L, getElem(L1, i1++));
return L;
}

int main(void)
{
List L,L1,L2;
int leng1,leng2;
int i;

initial(&L1);
initial(&L2);

srand(time(NULL));

do
{
printf("输入线性表 L1 的元素个数 (1 与 100 (含)之间)：");
scanf("%d", &leng1);
} while (leng1<0 || leng1>100);

do
{
printf("输入线性表 L2 的元素个数 (1 与 100 (含)之间)：");
scanf("%d", &leng2);
} while (leng2<0 || leng2>100);
printf("-------------------------------------------\n");

for (i=0; i<leng1; i++) insert(&L1, rand() % 200);
printf("线性表 L1：\n");
printlst(L1);

for (i=0; i<leng2; i++) insert(&L2, rand() % 200);
printf("线性表 L2：\n");
printlst(L2);

L = union_list(L1, L2);
printf("L1和L2的并集：\n");
printlst(L); // 打印合并的线性表

L = intersection_list(L1, L2);
printf("L1和L2的交集：\n");
printlst(L); // 打印交并的线性表

L = difference_list(L1, L2);
printf("L1-L2的差集：\n");
printlst(L); // 打印移除的线性表

return 0;
}