顺序线性表的基本操作算法

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <process.h>
#include <alloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10   //线性表存储空间的分配增量
int cunzai=0;
typedef int Status;
typedef int ElemType;
typedef struct
{
ElemType *elem;           //存储空间基址
int length;               //当前长度
int listsize;             //当前分配的存储空间(以sizeof(ElemType)为单位)
}SqList;

Status InitList_Sq(SqList *L)
//构造一个空的线性表L。
{
 L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
 if(!L->elem)
 exit(OVERFLOW);             //存储空间分配失败
 L->length=0;                //空表长度为0
 L->listsize=LIST_INIT_SIZE; //初始化存储容量 return OK;
 cunzai=1;
 return OK;
}//InitList_Sq

Status ListInsert_Sq(SqList *L,int i,ElemType e)
//在顺序线性表L中第i个位置之前插入新的元素e.
//i的合法值为1<=i<=ListLength_Sq(L)+1
{
 ElemType *newbase,*q,*p;
 if(i<1||i>L->length+1)
 return ERROR;//i值不合法
 if(L->length>=L->listsize) //当前存储空间已满，增加分配
 {
  newbase=(ElemType *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));
  if(!newbase)
  exit(OVERFLOW);            //存储空间分配失败
  L->elem=newbase;           //新基址
  L->listsize+=LISTINCREMENT;   //增加存储容量
 }
  q=L->elem+(i-1);           //q为插入位置
  for(p=L->elem+(L->length-1);p>=q;--p)
  *(p+1)=*p;                   //插入位置及之后的元素右移
  *q=e;                        //插入e
  ++L->length;                 //表长增1
}//ListInsert_Sq

Status ListDelete_Sq(SqList *L,int i,ElemType *e)
//在顺序表L中删除第i个元素，并用e返回其值
//i的合法值为1<=i<=ListLength_Sq(L)
{
ElemType *p,*q;
 if((i<1)||(i>L->length))
 return ERROR;               //i值不合法
 p=L->elem+(i-1);           //p为被删除元素的位置
 *e=*p;                       //被删除元素的值赋给e
 q=L->elem+(L->length-1);     //表尾元素的位置
 for(++p;p<=q;++p)
 *(p-1)=*p;                  //被删除元素之后的元素左移
 --L->length;                //表长减1
 return OK;
}//ListDelete_Sq

Status DestroyList_Sq(SqList *L)
//初始条件:线性表L存在。
//操作结果:销毁线性表L。
{
 if(!(cunzai==1))                     //检测是否存在?
 return INFEASIBLE;
 free(L);
 cunzai=0;
 return OK;
}//DestroyList_Sq

Status ClearList_Sq(SqList *L)
//初始条件:线性表L已存在。
//操作结果:将L重置为空表.
{
 if(!(cunzai==1))                    //检测是否存在
 return INFEASIBLE;
 L->length=0;
 L->listsize=LIST_INIT_SIZE;
 free(L->elem);                    //释放基地址内存
 L->elem=NULL;
 return OK;
}//ClearList_Sq

Status ListEmpty_Sq(SqList *L)
//初始条件:线性表L已存在.
//操作结果:若L为空表，则返回TRUE,否则返回FALSE.
{
 if(!(cunzai==1))                 //检测是否存在表
 return INFEASIBLE;
 if(!L->length)
 return TRUE;
 else
 return FALSE;
}//ListEmpty_Sq

Status ListLength_Sq(SqList *L)
//初始条件:线性表L已存在
//操作结果:返回L中数据元素个数
{
 if(!(cunzai==1))
 return INFEASIBLE;
 return L->length;
}//ListLength_Sq

Status GetElem_Sq(SqList *L,int i,int *e)
//初始条件:线性表L已存在,1<=i<=ListLength(L)
//操作结果:用e返回L中第i个数据元素的值
{
 if(!(cunzai==1))
 return INFEASIBLE;
 *e=*(L->elem+(i-1));
 return OK;
}//GetElem_Sq

Status compare(ElemType a,ElemType b)
//两个数比较大小,若相等返回TRUE,若不相等则返回FALSE.
{
 if(!a&&!b)
 return OVERFLOW;
 if(a==b)
 return TRUE;
 else
 return FALSE;
}//compare

Status LocateElem_Sq(SqList *L,ElemType e,Status (*c)(ElemType,ElemType))
//在顺序表L中找第一个与e满足compare()的元素的位序
//若找到,则返回其在L中的位序,否则返回0
{
 int i=1;            //i的初值为第一个元素的位序
 ElemType *p;
 p=L->elem;     //p的初值为第一个元素的存储位置
 while(i<=L->length&&!(*c)(*p++,e))
 ++i;
 if(i<=L->length)
 return i;
 else
 return 0;
}//LocateElem_Sq

Status PriorElem_Sq(SqList *L,int cur_e,int *pre_e)
//线性表L已存在
//若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义.
{
  int i;
  if(!(cunzai==1))
  return INFEASIBLE;
  i=LocateElem_Sq(L,cur_e,compare);             //找到cur_e在表L中的位置
  if(i!=1)
   {
   *pre_e=*(L->elem+(i-2));                     //驱前驱元素
   return *pre_e;
   }
  return ERROR;
}//PriorElem_Sq

Status NextElem_Sq(SqList *L,int cur_e,int *next_e)
//线性表L已存在
//若cur_e是L的数据元素,且不是最后一个?则用next_e返回它的后驱,否则操作失败,  next_e无定义.
{
  int i;
  if(!(cunzai==1))
  return INFEASIBLE;
  i=LocateElem_Sq(L,cur_e,compare);             //找到cur_e在表L中的位置
  if(i!=L->length)
   {
   *next_e=*(L->elem+i);                        //取后驱元素
   return *next_e;
   }
  return ERROR;
}//NextElem_Sq

void Union_Sq(SqList *La,SqList *Lb)
//将所有在线性表Lb中但不在La中的数据元素插入到La中
{
 int La_len,Lb_len,i;
 ElemType e;
 La_len=ListLength_Sq(La);
 Lb_len=ListLength_Sq(Lb);              //求线性表的长度
 for(i=1;i<=Lb_len;i++)
 {
  GetElem_Sq(Lb,i,&e);            //取Lb中第i个数据元素赋给e
  if(!LocateElem_Sq(La,e,compare))
  {
  ListInsert_Sq(La,++La_len,e);     //La中不存在和e相同的数据元素,则插入之
  La->length++;
  }
 }
}//Union_Sq

void MergeList_Sq(SqList La,SqList Lb,SqList *Lc)
//已知顺序线性表La和Lb的元素按值非递减排列
//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列
{
 ElemType *pa,*pb,*pc,*pa_last,*pb_last;
 pa=La.elem;
 pb=Lb.elem;
 Lc->listsize=Lc->length=La.length+Lb.length;
 pc=Lc->elem=(ElemType*)malloc(Lc->listsize*sizeof(ElemType));
 if(!Lc->elem)
 exit(OVERFLOW);                             //存储分配失败
 pa_last=La.elem+La.length-1;
 pb_last=Lb.elem+Lb.length-1;
 while((pa<=pa_last)&&(pb<=pb_last))             //归并
{
 if(*pa<=*pb)
 *pc++=*pa++;
 else
 *pc++=*pb++;
}
while(pa<=pa_last)
*pc++=*pa++;                                //插入La的剩余元素
while(pb<=pb_last)
*pc++=*pb++;                                   //插入Lb的剩余元素
}//MergeList_Sq