利用静态链表作集合运算（A-B）U(B-A)

静态链表基本操作的头文件：SLinkList.h

#include<iostream>
using namespace std;
#define MAXSIZE 1000
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int ElemType;
typedef int Status;
typedef struct
{
 ElemType data;
 int next;
}component,SLinkList[MAXSIZE];

//基本算法1：将一维数组space中各分量链成一个备用链表，space[0].cur为头指针
void InitSpace_SL(SLinkList& space)
{
 for (int i = 0; i < MAXSIZE - 1; ++i)
  space[i].next = i + 1;
 space[MAXSIZE - 1].next = 0;
}

//基本算法2:若备用空间链表非空，则返回分配的结点下标，否则返回0
int Malloc_SL(SLinkList& space)
{
 int i = space[0].next;
 if (space[0].next)
 {
  space[0].next = space[i].next;
  return i;
 }
 else
  return 0;
}

//基本算法3：将下标为k的空闲结点回收到备用链表
void Free_SL(SLinkList& space, int k)
{
 space[k].next = space[0].next;
 space[0].next = k;
}

//构造一个空的静态链表L
Status InitList_SL(SLinkList& S)
{
 InitSpace_SL(S);
 int L = Malloc_SL(S);
 S[L].next = 0;
 return OK;
}

//销毁静态链表S
Status DestroyList_SL(SLinkList& S)
{
 S[0].next=0;
 return OK;
}

//将静态链表置为空表
Status ClearList_SL(SLinkList& S)
{
 int j,k = S[1].next;
 while (k)
 {
  j = S[k].next;
  Free_SL(S, k);
  k = j;
 }
 S[1].next = 0;
 return OK;
}

//若静态链表为空表，则返回TRUE，否则返回FALSE
Status ListEmpty_SL(SLinkList S)
{
 if (S[1].next)
  return FALSE;
 else
  return TRUE;
}

//返回静态链表S中数据元素的个数
int ListLength_SL(SLinkList S)
{
 int k = 1,length=0;
 while (S[k].next)
 {
  ++length;
  k = S[k].next;
 }
 return length;
}

//用e返回第i个数据元素的值
Status GetElem_SL(SLinkList S, int i, ElemType &e)
{
 if ((i<1) || (i>ListLength_SL(S)))
  return ERROR;
 int k = 1;
 for (int j = 0; (S[k].next )&& (j < i); ++j)
  k = S[k].next;
 e = S[k].data;
 return OK;
}

//返回值为e的元素的位序
int LocateElem_SL(SLinkList S, ElemType e)
{
 int i = S[1].next,position=1;
 while (i&&S[i].data != e)
 {
  ++position;
  i = S[i].next;
 }
 if (S[i].data == e)
  return position;
 else
  return 0;
}

//若cur_e是静态链表S的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
Status PriorElem_SL(SLinkList S, ElemType cur_e, ElemType& pre_e)
{
 int i = S[1].next;
 while (i&&S[i].next)
 {
  int j = S[i].next;
  if (S[j].data == cur_e)
  {
   pre_e = S[i].data;
   return OK;
  }
  i = j;
 }
 return INFEASIBLE;
}

//若cur_e是静态链表S的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无定义
Status NextElem_SL(SLinkList S, ElemType cur_e, ElemType& next_e)
{
 int i = LocateElem_SL(S, cur_e);
 if (i)
 {
  int j = S[i].next;
  if (j)
  {
   next_e = S[j].data;
   return OK;
  }
 }
 return INFEASIBLE;
}

//在静态链表中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert_SL(SLinkList& S, int i, ElemType e)
{
 if (i < 1 || i>ListLength_SL(S) + 1)
  return ERROR;
 int j = Malloc_SL(S), p = 1,num=1;
    S[j].data=e;
 while (p && num < i)
 {
  p = S[p].next;
  num++;
 }
 if (!p || num>i)
  return ERROR;
 S[j].next = S[p].next;
 S[p].next = j;
 return OK;
}

//删除静态链表S中第i个数据元素，并用e返回其值
Status ListDelete_SL(SLinkList& S, int i,ElemType& e)
{
 if (i<1 || i>ListLength_SL(S))
  return ERROR;
 int num=0,p =1,q=S[1].next;
 while (q)
 {
  num++;
  if (num == i)
  {
   S[p].next = S[q].next;
   Free_SL(S, q);
   return OK;
  }
  p = q;
  q = S[q].next;
 }
 return ERROR;
}

//打印静态链表S中的数据元素
Status visit(ElemType i)
{
 if (cout << i<<"  ")
  return OK;
 else
  return ERROR;
}
//依次对静态链表L的每个数据元素调用visit().一旦调用失败，则操作失败
Status ListTraverse_SL(SLinkList S, Status(*visit)(ElemType))
{
 int p = S[1].next;
 while (p)
 {
  if (!visit(S[p].data))
   return ERROR;
  p = S[p].next;
 }
 return OK;
}

主函数：

#include"SLinkList.h"
void difference(SLinkList& space, int& S)
{
 InitSpace_SL(space);
 S = Malloc_SL(space);
 int r = S;
 cout << "分别输入集合A和集合B的元素个数:";
 int i,m, n;
 cin >> m >> n;
 cout << endl;
 for (int j = 1; j <= m; ++j)
 {
  i = Malloc_SL(space);
  cout << "输入集合A的元素:";
  cin >> space[i].data;
  space[r].next = i;
  r = i;
 }
 space[r].next = 0;
 int b, p, k;
 for (int j = 1; j <= n; ++j)
 {
  cout << "输入集合B的元素:";
  cin >> b;
  p = S;
  k = space[S].next;
  while ((k != space[r].next) && (space[k].data != b))
  {
   p = k;
   k = space[k].next;
  }
  if (k == space[r].next)
  {
   i = Malloc_SL(space);
   space[i].data = b;
   space[i].next = space[r].next;
   space[r].next = i;
  }
  else
  {
   space[p].next = space[k].next;
   Free_SL(space, k);
   if (r == k)
    r = p;
  }
 }
}

void main(void)
{
 SLinkList S;
 int L;
 difference(S, L);
    ListTraverse_SL(S, visit);
 cout << endl;
}