顺序表

SqList.c

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10 

typedef struct {
    ElemType *elem;
    int length;
    int listsize;
}SqList;

Status InitList(SqList *L){  //操作结果：构造一个空的顺序表L。 
    L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!L->elem)
        exit(OVERFLOW);   
    L->length=0;                                    
    L->listsize=LIST_INIT_SIZE;
    return OK;
}

Status DestroyList(SqList *L){ //初始条件：顺序表L已存在。
//操作结果：销毁顺序表L。 
    free(L->elem);
    L->elem=NULL;
    L->length=0;
    L->listsize=0;
    return OK;
}

Status ClearList(SqList *L){ //初始条件：顺序表L已存在。
//操作结果：将L重置为空表。 
    L->length=0;
    return OK;
}

Status ListEmpty(SqList L){ //初始条件：顺序表L已存在。
//操作结果：若L为空表，则返回TRUE，否则返回FALSE 
    if(L.length==0)
        return TRUE;
    else
        return FALSE;
}

Status ListLength(SqList L){ //初始条件：顺序表L已存在。
//操作结果：返回L中数据元素的个数。 
    return L.length;
}

Status GetElem(SqList L,int i,ElemType *e){ //初始条件：顺序表L已存在，1<=i<=ListLength(L)。
//操作结果：用e返回L中第i个数据元素的值。 
    if(i<1||i>L.length)
        exit(INFEASIBLE);
    *e=*(L.elem+i-1);
    return OK;
}

Status LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)){ //初始条件：顺序表L已存在，compare()是数据元素判定函数。
//操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 若这样的数据元素不存在，则返回值为0。 
    int i=1;
    ElemType *p=L.elem;
    while(i++<=L.length){
        if(compare(e,*p++))
            return i-1;
    }
    return FALSE;
}

Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e){ //初始条件：顺序表L已存在。 
//操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。 
    int i=2; 
    ElemType *p=L.elem+1;
    while(i++<=L.length){
        if(cur_e==*p++){
            *pre_e=*(p-2); 
            return OK;
        }
    } 
    return FALSE;
}

Status NextElem(SqList L,ElemType cur_e,ElemType *next_e){ //初始条件：顺序表L已存在。 
//操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继,否则操作失败，next_e无定义。 
    int i=1;
    ElemType *p=L.elem;
    while(i++<L.length){
        if(cur_e==*p++){ 
            *next_e=*p;
            return OK;
        }
    }
    return FALSE;
}

Status ListInsert(SqList *L,int i,ElemType e){ //初始条件：顺序表L已存在，1<=i<=ListLength(L)+1。 
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。 
    ElemType *newbase,*p; 
    if(i<1||i>L->length+1)
        exit(INFEASIBLE);
    if(L->listsize<=L->length){
        newbase=(ElemType *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase)
            exit(OVERFLOW);
        L->elem=newbase;
        L->listsize+=LISTINCREMENT; 
    }

    for(p=L->elem+L->length-1;p>=L->elem+i-1;p--) 
        *(p+1)=*p;
    *++p=e;
    L->length++;
    return OK; 

    /*
    for(int j=L->length;j>=i;j--)
        L->elem[j+1-1]=L->elem[j-1];
    L->elem[i-1]=e;
    L->length++;
    */ 
}

Status ListDelete(SqList *L,int i,ElemType *e){ //初始条件：顺序表L已存在，1<=i<=ListLength(L)。 
//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1。 
    ElemType *newElem,*p; 
    if(i<1||i>L->length+1)
        exit(INFEASIBLE);

    *e=*L->elem+i-1;
    for(p=L->elem+i-1;p<=L->elem+L->length-1;p++) 
        *p=*(p+1);
    L->length--;
    return OK;

    /*
    *e=L->elem[i-1];
    for(int j=i;j<L->length;j++)
        L->elem[j-1]=L->elem[j];
    L->length--;
    */      
}

Status ListTraverse(SqList L,Status(*visit)(ElemType*)){ //初始条件：顺序表L已存在。 
//操作结果：依次对L的每个数据元素调用函数visit()。一旦visit()失败，则操作失败。 
    ElemType *p=L.elem;
    while(p<L.elem+L.length){
        if(!visit(p++))
            exit(ERROR);
    }
    return OK;
}