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

#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