顺序表的实现

#include  
using namespace std;  
 
//常量值定义  
#define OK                      1  
#define ERROR                   0  
#define TRUE                    1  
#define FALSE                   0  
#define OVERFLOW                -1        
#define UNDERFLOW               -2  
#define LIST_INIT_SIZE          100  
#define LISTINCREMENT           10  
   
//函数返回值类型定义  
typedef int Status;  
 
//数据元素类型定义  
typedef int ElemType;     
 
//顺序表结构定义  
typedef struct{  
    ElemType    *elem;  
    int        length;  
    int        listsize;  
}SqList;  
 
//辅助函数的声明
bool compare( ElemType, ElemType );//比较两个元素，看是否满足指定的条件  
typedef bool (*pCompare)( ElemType, ElemType ); //函数指针  
 
Status  output( ElemType );//输出数据元素  
typedef Status (*pOutput)( ElemType );  
 
//顺序表基本操作的声明  
Status  InitList( SqList& );//初始化顺序表  
Status  DestroyList( SqList& );//销毁顺序表  
Status  ClearList( SqList& );//清空顺序表  
bool    ListEmpty( SqList& );//判断顺序表是否为空  
int     ListLength( SqList& );//获取顺序表的长度  
Status  GetElem( SqList&, int, ElemType& );//随机访问顺序表中的元素  
Status  LocateElem( SqList&, ElemType, int&, pCompare );//按指定的规则在顺序表中查找元素  
Status  PriorElem( SqList&, ElemType, ElemType& );//返回指定元素的前驱
Status  NextElem( SqList&, ElemType, ElemType& );//返回指定元素的后继
Status  ListInsert( SqList&, int, ElemType );//在顺序表中的指定位序的元素之前插入一个元素
Status  ListDelete( SqList&, int, ElemType& );//删除顺序表中指定位序的元素，并返回该元素
Status  ListTraverse( SqList&, pOutput );//遍历顺序表，并将每个数据元素输出

bool compare(ElemType e1, ElemType e2) //操作结果：比较e1和e2是否相等，若相等，返回TRUE；否则，返回FALSE 
{  
    if(e1==e2)  
        return TRUE;  
    else 
        return FALSE;  
}  
 
Status  output( ElemType e )  
//操作结果：将e在屏幕上输出  
{  
    cout<<e<<" ";  
    return OK;  
}  
 
Status InitList( SqList &L )  
//操作结果：构造一个空的线性表L，按照指定的大小分配存储空间  
{  
    L.elem =( ElemType* )malloc( LIST_INIT_SIZE * sizeof( ElemType ) );  
    if( L.elem == NULL )
    {  
        cout<<"顺序表初始化失败"<<endl;  
        exit( OVERFLOW );  
    }  
 
    L.length = 0;  
    L.listsize = LIST_INIT_SIZE;  
    return OK;  
}  
 
Status DestroyList( SqList &L )  
//初始条件：线性表L已存在  
//操作结果：销毁线性表  
{  
    free( L.elem );  
    L.elem = NULL;  
    L.length=0;  
    L.listsize=0;  
    return OK;  
}  
 
Status ClearList( SqList &L )  
//初始条件：线性表L已存在  
//操作结果：将L置为空表  
{  
    free( L.elem );  
 
    L.elem=( ElemType* )malloc( LIST_INIT_SIZE * sizeof( ElemType ) );//重新分配预设的LIST_INIT_SIZE大小的存储空间  
    if( L.elem==NULL )
 {  
        cout<<"存储空间分配失败"<<endl;  
        return ERROR;  
    }  
 
    L.length=0;  
    L.listsize = LIST_INIT_SIZE;  
    return OK;  
}  
 
bool ListEmpty( SqList &L )  
//初始条件：线性表L已存在  
//操作结果：若L为空表，则返回TRUE；否则，返回FALSE  
{  
    if( L.length != 0 )  
        return FALSE;  
    else 
        return TRUE;  
}  
 
int ListLength( SqList &L )  
//初始条件：线性表L已存在  
//操作结果：返回L中数据元素的个数  
{  
    return L.length;  
}  
 
Status GetElem( SqList &L, int index, ElemType &e )  
//初始条件：线性表L已存在，1<=index<=ListLength(L)  
//操作结果：用e返回L中第index个数据元素的值  
{  
    if( (index < 1 ) || ( index>L.length ) )
 {  
        cout<<"查找位置不合理！"<<endl;  
        return ERROR;  
    }  
    e=L.elem[index-1];  
    return OK;  
}  
 
Status LocateElem( SqList &L, ElemType e, int &pos, pCompare comFun)  
//初始条件：线性表L已存在，comFun是指向compare()函数的指针  
//操作结果：返回L中第1个与e满足关系compare()的数据元素的位置。若这样的数据元素  
//不存在，返回ERROR  
{  
    int i=0;  
    for(;(i < L.length) && (comFun(e,L.elem[i])==FALSE);i++)  
        ;   //循环体为空
    if( i>L.length-1 )
 {  
        cout<<"未找到元素"<<endl;  
        return ERROR;  
    }  
    else
 {  
        pos=i;  
        return OK;  
    }  
}  
 
Status  PriorElem( SqList &L, ElemType e, ElemType &priElem)  
//初始条件：线性表L已存在  
//操作结果：若e是L的数据元素，且不是第一个，则用priElem返回它的前驱，否则，操作失败。  
{  
    int i;
    if( LocateElem( L, e, i, compare )==ERROR)
        return ERROR;
    if(i==0)
 {
        cout<<"该元素不存在前驱"<<endl;  
        return ERROR;
    }
    priElem = L.elem[i-1];  
    return OK;  
}  
 
Status  NextElem( SqList &L, ElemType e, ElemType &nextElem)  
//初始条件：线性表L已存在  
//操作结果：若e是L的数据元素，且不是最后一个，则用nextElem返回它的后继，否则，操作失败  
{  
    int i;  
    if(LocateElem( L, e, i, compare )==ERROR)  
        return ERROR;  
    if( i== L.length-1 ){  
        cout<<"该元素不存在后继"<<endl;  
        return ERROR;  
    }  
    nextElem=L.elem[i+1];  
    return OK;  
}  
 
Status  ListInsert( SqList &L, int index,ElemType e)  
//初始条件：线性表L已存在，1<=i<=ListLength(L)+1  
//操作结果：在L中的第index个元素之前插入新的数据元素e，L的长度加1  
{  
    if((index<1) || (index>L.length+1)){  
        cout<<"插入的位置不合理"<<endl;  
        return ERROR;  
    }  
 
    if(L.length>=L.listsize){  
        ElemType *newbase=(ElemType*)realloc( L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType));  
        if(newbase==NULL){  
            cout<<"增量存储空间分配失败"<<endl;  
            exit(OVERFLOW);  
        }  
        else{  
            L.elem = newbase;  
            L.listsize += LISTINCREMENT;  
        }  
              
    }  
 
    //移动元素  
    int i = L.length;  
    for(; i>index-1 ;i--)  
        L.elem[i]=L.elem[i-1];  
      
    //插入元素  
    L.elem[index-1]=e;  
 
    //修改表长  
    L.length++;  
    return OK;  
}  
 
Status  ListDelete( SqList &L, int index, ElemType &e)  
//初始条件：线性表L已存在且非空，1<=i<=ListLength(L)  
//操作结果：删除L的第index个元素，并用e返回其值，L的长度减1  
{  
    if((index<1) || (index>L.length)){  
        cout<<"删除的位序不合理"<<endl;  
        return ERROR;  
    }  
 
    if( L.length == 0 ){  
        cout<<"顺序表为空，删除错误"<<endl;  
        exit(UNDERFLOW);  
    }  
 
    e=L.elem[index-1];  
    int i=index-1;  
    for(;i
        L.elem[i]=L.elem[i+1];  
 
    //修改表长  
    L.length--;  
    return OK;  
}

Status  ListTraverse( SqList &L, pOutput outFun)  
//初始条件：线性表L已存在  
//操作结果：依次对L的每个数据元素调用函数output()。  
{  
    if(L.length == 0){  
        cout<<"顺序表为空，遍历失败"<<endl;  
        return ERROR;  
    }  
 
    for(int i=0;i
        outFun( L.elem[i] );  
    cout<<endl;  
 
    return OK;  
}