顺序表示的线性表——顺序表2

合并两个线性表中的元素，相同的元素只保留一个

SeqList.h

#pragma once
#define ListSize 200
#include <iostream>
using namespace std;
typedef int DataType;
typedef struct
{
	DataType list[ListSize];
	int length;
}SeqList;

//初始化线性表
void InitList(SeqList *L)
{

	L->length = 0;//把线性表长度置为0
}
//判断线性表是否为空,线性表为空返回1，否则返回0
int ListEmpty(SeqList L)
{
	if (L.length == 0)
		return 1;
	else
		return 0;
}

//按照序号查找
int GetElem(SeqList L, int i, DataType *e)
/*查找线性表中第i个元素，查找成功返回给e，并返回1表示成功，否则返回-1，表示失败*/
{
	if (i<1 || i>L.length)
		return -1;
	else
		*e = L.list[i - 1];
	return 1;

}
//按照内容查找
int LocateElem(SeqList L, DataType e)
{
	int i;
	for (i = 0; i < L.length; i++)/*从第一个元素开始与e进行比较*/
		if (L.list[i] == e)       /*若存在与e相等的元素*/
			return i + 1;         /*返回该元素的在线性表中的序号*/
	return 0;                     /*否则，返回0 */
}
//插入操作
int InsertList(SeqList *L, int i, DataType e)
/*在顺序表中的第i个位置插入元素e，插入成功返回1，插入不合法返回-1，顺序表满返回0.*/
{
	int j;
	if (i<1||i>L->length+1)/*在插入元素前，判断插入位置是否合法*/
	{
		cout <<"插入位置"<<i<<"不合法！" << endl;
		return -1; 
	}
	else if (L->length>=ListSize)/*在插入元素之前，判断顺序表是否已经满，不能插入元素*/
	{
		cout << "顺序表已经满，不能插入元素。" << endl;
		return 0;

	}
	else
	{
		for (j = L->length; j >= i; j--)
			/*将第i个位置以后的元素依次后移*/
		{
			L->list[j] = L->list[j - 1];
		}
		L->list[i - 1] = e;
		L->length = L->length + 1;
		return 1;

		
	}
}
/*删除操作，删除第i个元素*/
int DeleteList(SeqList *L, int i, DataType *e)
{
	int j;
	if (L->length<=0)
	{
		cout << "顺序表表已空，不能进行删除！" << endl;
		return 0;

	}
	else if (i<1||i>L->length)
	{
		cout << "删除位置不合适！" << endl;
		return -1;
	}
	else
	{
		*e = L->list[i - 1];
		for (j = i; j <= L->length - 1;j++)
		{
			L->list[j - 1] = L->list[j];

		}
	    L->length = L->length - 1;
	    return 1;
	}
}
/*求线性表的长度*/
int ListLength(SeqList L)
{
	return L.length;
}

/*清空顺序表*/
void ClearList(SeqList *L)
{
	L->length = 0;
}

main.cpp

/*合并两线性表中的元素，相同元素只保留一个*/
#include"SeqList.h"
/*将线性表LB中但不在线性表LA中的元素插入线性表LA中*/
void UnionAB(SeqList *A, SeqList B);

void main()
{
	int i, flag;
	DataType e;
	DataType a[] = { 81, 32, 61, 12, 39, 25 };
	DataType b[] = { 12, 44, 39, 16, 28, 6, 61, 76 };
	/*声明顺序表LA， LB*/
	SeqList LA, LB;
	/*初始化顺序表LA，LB*/
	InitList(&LA);
	InitList(&LB);
	/*将a数组的元素插入LA中*/
	for ( i = 0; i < sizeof(a)/sizeof(a[0]); i++)
	{
		if (InsertList(&LA,i+1,a[i])==0)
		{
			cout << "位置不合法！" << endl;
			return;
		}
	}
	/*将b数组中的元素插入 LB中*/
	for ( i = 0; i < sizeof(b)/sizeof(b[0]); i++)
	{
		if (InsertList(&LB, i+1, b[i])==0)
		{
			cout << "位置不合法！" << endl;
			return;
		}
	}
	cout << "顺序表LA中的元素：" << endl;
	/*输出LA中的每一个元素*/
	for ( i = 1; i <= LA.length; i++)
	{
		flag = GetElem(LA, i, &e);
		if (flag==1)
		{
			cout << e <<" ";
		}
	}
	cout << endl;
	cout << "顺序表LB中的元素：" << endl;
	/*输出LB中的每一个元素*/
	for ( i = 1; i <= LB.length; i++)
	{
		flag = GetElem(LB, i, &e);
		if (flag==1)
		{
			cout << e <<" ";
		}
	}
	cout << endl;
	cout << "将LB中但不在LA中的元素插入LA中：" << endl;
	UnionAB(&LA, LB);
	/*输出合并后的LA表*/
	for ( i = 1; i <= LA.length; i++)
	{
		flag = GetElem(LA, i, &e);
		if (flag==1)
		{
			cout << e << " ";
		}
	}
	cout << endl;
	getchar();
}

/*删除LA中出现LB元素的函数实现*/
void UnionAB(SeqList *LA, SeqList LB)
{
	int i, flag, pos;
	DataType e;
	for ( i = 1; i <= LB.length; i++)
	{
		flag = GetElem(LB, i, &e);
		if (flag==1)
		{
			pos = LocateElem(*LA, e);/*在LA中查找和LB中取出的e元素相等的元素*/
			if (!pos)
			{
				InsertList(LA, LA->length + 1, e);/*如果找到该元素将元素插入LA中，在LA最后一个元素后面插入*/
			}
		}
	}
}

结果：