顺序存储结构线性表的C语言实现

///
//---------------------------------------------------------
//           // 顺序存储结构线性表基本操作//
//            a simple example of Sq_List by C language
// 
//                 by wilson Sep.4.2012 
//---------------------------------------------------------
///


#include  
#include 

//以下为函数运行结果状态代码

#define TRUE 1
#define FALSE 0
#define OK 1 
#define ERROR 0 
#define INFEASIBLE -1 
#define OVERFLOW -2 

#define LIST_INIT_SIZE 5     //线性表存储空间的初始分配量
#define LISTINCREMENT 1     //线性表存储空间分配增量

typedef int Status;         //函数类型，其值为为函数结果状态代码

typedef int ElemType;      //假设数据元素为整型

typedef struct Sqlist
{ 
    ElemType *elem;          //存储空间基址
    int length;                //当前长度
    int listsize;              //当前分配的存储容量
}Sqlist; 
//实现线性表的顺序存储结构的类型定义

static Sqlist L;              //为了引用方便，定义为全局变量
static ElemType e;

///
//函数名：InitList()   {结构初始化}
//参数：SqList L
//初始条件：无
//功能：构造一个空线性表
//返回值：存储分配失败：OVERFLOW
//        存储分配成功：OK
///
Status InitList(SqlistL)
{
    L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(L.elem==NULL)                     //存储分配失败
        exit(OVERFLOW);
    else
    {
        L.length=0;                     //空表长度为0
        L.listsize=LIST_INIT_SIZE;   //初始存储容量
        return OK;
    }
}

///
//函数名：DestroyList()     {结构销毁}
//参数：SqList L
//初始条件：线性表L已存在
//功能：销毁线性表
//返回值：L.elem==NULL:ERROR
//        L.elem!=NULL:OK
///
Status DestroyList(SqlistL)
{
    if(L.elem==NULL)
        return ERROR;
    else
        free(L.elem);
    return OK;
}

///
//函数名：ClearList()
//参数：SqList L
//初始条件：线性表L已存在
//功能：清空线性表
//返回值：L.elem==NULL:ERROR
//        L.elem!=NULL:OK
///
Status ClearList(SqlistL)
{
    if(L.elem==NULL)
        exit(ERROR);
    int i;
    ElemType *p_elem=L.elem;
    for(i=0;iListLength(L))：OVERFLOW
//        1<=i<=ListLength(L)：element
///
ElemType GetElem(SqlistL,int i，&element)
{
    int j;
    ElemType *p_elem=L.elem;
    if(i<1||i>L.length)                      //输入的i不合法
        return OVERFLOW; 
    for(j=1;j<=i;j++)
        L.elem++;
    element=*L.elem;                         //得到了第i个元素的值
    L.elem=p_elem;                           //返回头指针
    return element;
}

///
//函数名：LocateElem()
//参数：Sqlist L,ElemType element
//初始条件：线性表L已存在
//功能：返回顺序表L中第1个与element相等的元素
//返回值：若在L中存在于element相等的元素：其位序
//        若在L中不存在与element相等的元素：0
///
int LocateElem(SqlistL,ElemType element)
{
    int i;
    ElemType *p_elem=L.elem;
    for(i=1;i1&&i<=L.length，LocateElem()存在（当前）
//功能：用pre_e返回线性表中cur_e的前驱
//返回值：i<=1||i>L.length：OVERFLOW
//        i>1&&i<=L.length：OK
///
Status PriorElem(SqlistL,ElemType cur_e,ElemType*pre_e)
{
    ElemType *p_elem=L.elem;
    int i,j;
    i=LocateElem(L,cur_e);
    if(i<=1||i>L.length)                //i=1时为为顺序表的第一个位置
        exit(OVERFLOW);
    for(j=1;j=1&&i=L.length：OVERFLOW
//        i>=1&&i=L.length)        // i=l.length 时表示为表的最后一个元素
        exit(OVERFLOW);
    for(j=1;j<=i+1;j++)
    {
        if(j==(i+1))
        {
            next_e=L.elem;
            L.elem=p_elem;
            return OK;
        }
        else
            L.elem++;
    }
}

///
//函数名：ListInsert()
//参数：SqList L,int i,ElemType e
//初始条件：线性表L已存在，1<=i<=ListLength(L)+1
//功能：在线性表中第i个数据元素之前插入数据元素e
//返回值：失败：ERROR
//        成功：OK
///
Status ListInsert(SqlistL,int i,ElemType e)
{
    int *q=&(L.elem[i-1]);
    ElemType *newbase,*p;
    if(i<1||i>(L.length+1))              //i值不合法
        return ERROR;
    if(L.length>=L.listsize)   //当前存储空间已满，增加分配
    {
        newbase=(ElemType*)realloc(L.elem,L.listsize+LISTINCREMENT*sizeof(ElemType));
        if(newbase==NULL)            //存储分配失败
            exit(OVERFLOW);
        L.elem=newbase;              //赋予新的基地址
        L.listsize+=LISTINCREMENT; //增加的存储容量
    }

q=&(L.elem[i-1]);                 //插入元素的位置
    for(p=&(L.elem[L.length-1]);p>=q;--p)
        *(p+1)=*p;                 //插入元素位置之后的所有元素向后移1位
    *q=e;                            //插入元素e
    ++L.length;                     //表长增加1
    return OK;
}

///
//函数名：ListDelete()
//参数：SqList L,int i,Elemtype e
//初始条件：线性表L已存在，1<=i<=ListLength(L)
//功能：将线性表L中第i个数据元素删除
//返回值：失败：ERROR
//        成功：OK
///
Status ListDelet(SqlistL,int i,ElemType e)
{
    if(i<1||(i>L.length))
        return ERROR;
    ElemType *p,*q;
    p=&(L.elem[i-1]); //删除元素的位置，在Sqlist中i位置元素为L.elem[i-1]
    e=*p;              //被删除元素的值赋给e
    q=L.elem+L.length-1; //表尾位置
    for(++p;p<=q;++p)
        *(p-1)=*p;        //p后面的元素都向前移（左）一位
    --L.length;
    return OK;
}

 

 

///
//函数名：union()
//参数：SqList La,SqList Lb
//初始条件：线性表La,Lb已存在
//功能：将所有在线性表Lb中但不在La中的元素插入到La中
//返回值：失败：ERROR
//        成功：OK
///
void union(SqList &La, SqList Lb)

{

int i;

if(La.length==0||Lb.length==0) return ERROR;

for(i=0;i<=Lb.length;i++)

{

   GetElem(Lb,i,e);          //得到Lb中的第i个元素的值

   If(!LacateElem(La,e))    //查看La中是否有e元素

       listInsert(La,++La.length,e);  //没有这将e元素插入表尾

}

retutn OK;

}