这是有关数据结构的例程序

				definition.h
				===========================================
				#define MAXSIZE 1000 
				typedef char ElemType;
				
				typedef struct{//定义静态链表结构
				ElemType data;
				unsigned short cur;
				}component, SLinkList[MAXSIZE];
				
				void Init(component *); //初始化静态链表
				component* Insert(component *); //插入数据到链表
				short Malloc(component *); //分配空间
				void Free(component *, short); //回收空间
				void Disp(component *, component *); //显示静态链表数据
				void Purge(component *, component *); //删除重复数据
				void Union(component *, component *, component *); //(A-B)交(B-A)
				======================================================
				
				
				functions.c
				======================================
				#include
				#include"definition.h"
				
				void Init(component *L)//初始化静态链表
				{ unsigned short i;
				
				for(i=0; i				L[i].cur=i+1;
				L[MAXSIZE-1].cur=0;
				}
				
				component* Insert(component *L)//插入数据到链表
				{ component *T, *temp1, *temp2;
				unsigned short i;
				ElemType ch;
				
				if( i=Malloc(L) ){
				T=temp1=&L[i];
				T->cur=0;
				} else
				return 0; 
				while( (ch=getchar()) != '\n' ){
				if( i=Malloc(L) ){
				temp2=&L[i];
				temp2->data=ch;
				temp2->cur=0;
				temp1->cur=i;
				temp1=temp2;
				} else
				return 0;
				}
				
				return T;
				}
				
				short Malloc(component *L)//分配空间
				{ unsigned short i;
				
				i=L[0].cur;
				if(L[0].cur){
				L[0].cur=L[i].cur;
				return i;//成功返回空间位置
				}
				
				return 0;//失败返回0
				}
				
				void Free(component *L, short i) //回收空间
				{ L[i].cur=L[0].cur;
				L[0].cur=i;
				}
				
				void Disp(component *T, component *L)//显示静态链表数据
				{ while(T->cur){
				T=&L[T->cur];
				printf("%c", T->data);
				} printf("\n");
				}
				
				void Purge(component *T, component *L) //删除重复数据
				{ component *tmp, *temp;
				
				for(T=&L[T->cur]; T->data; T=&L[T->cur]){//若T->data中没数据，则退出循环
				for(temp=T, tmp=&L[T->cur]; tmp->data;){//若tmp->data中没数据，则退出循环
				if(T->data==tmp->data){
				temp->cur=tmp->cur;
				Free(L, (short)(tmp-L));//回收空间
				tmp=&L[temp->cur];
				} else{
				tmp=&L[tmp->cur];
				temp=&L[temp->cur];
				} }
				} }
				
				void Union(component *A, component *B, component *L)//(A-B)交(B-A)
				{ component *T, *ta, *tb=B;
				short flag;//用于判断是否进行了删除操作
				
				B=&L[B->cur];
				while(B->data){//循环判断，直到B表中所有数据都和A表比较过后才结束
				ta=T=A;
				flag=1;//1代表没有进行删除
				while(T->cur){//循环判断，直到A表中所有数据都和B->data比较过后才结束
				T=&L[T->cur];
				if(T->data==B->data){//如果相等，则删除
				ta->cur=T->cur;
				Free(L, (short)(T-L));
				T=&L[ta->cur];
				tb->cur=B->cur;
				Free(L, (short)(B-L));
				B=&L[tb->cur];
				flag=0;//1代表进行了删除
				break;
				} else//不相等则把指针移动到一个数据
				ta=&L[ta->cur];
				} if(flag){//如果没有进行删除操作，则连接两个结点
				T->cur=tb->cur;
				tb->cur=B->cur;
				B->cur=0;
				B=&L[tb->cur];
				} }
				} ======================================================
				
				main.c
				=============================
				#include
				#include"definition.h"
				
				int main()
				{ SLinkList L;
				component *A, *B;
				
				L[0].data=0;
				Init(L);//初始化静态链表
				printf("请为静态链表A输入数据：");
				A=Insert(L);//插入数据到链表A
				printf("请为静态链表B输入数据：");
				B=Insert(L);//插入数据到链表B
				
				printf("静态链表A的数据为：");
				Disp(A, L);
				printf("静态链表A的数据为：");
				Disp(B, L);
				
				Purge(A, L);//删除A中重复元素
				printf("删除A中重复元素后得：");
				Disp(A, L);
				Purge(B, L);//删除B中重复元素
				printf("删除B中重复元素后得：");
				Disp(B, L);
				
				Union(A, B, L);//(A-B)交(B-A)
				printf("(A-B)交(B-A)得：");
				Disp(A, L);
				
				return 0;
				}