编写静态顺序表（3） seqtable.c文件

#include "seqtable.h"

//ST   ==   struct SeqTable *
//创建一个指定容量的顺序表   分配内存空间    fopen 
//返回NULL失败  如果成功返回顺序表的内存地址 
ST create_seqtable(size_t cap){
    ST st = (ST)malloc(STSIZE);  //申请 struct SeqTable结构体的内存地址 
    if(st != NULL){
        st->cap = cap;
        st->size = 0;
        st->elems = (ElemType*)calloc(cap,sizeof(ElemType));//申请 存储元素的内存地址 
        if(st->elems == NULL){
            free(st);
            st = NULL;
        }
    }
    return st;
}

//销毁顺序表         释放内存空间           fclose   FILE 
void destroy_seqtable(ST st){
    assert(st!=NULL);
    free(st->elems);
    free(st);
}

//静态顺序表    不能扩容    是否已满 
bool full_seqtable(ST st){
    assert(st!=NULL);
    return st->size == st->cap;
}

//顺序表是否为空 
bool empty_seqtable(ST st){
    assert(st!=NULL);
    return st->size == 0;
}

//顺序表中元素个数 
size_t size_seqtable(ST st){
    assert(st!=NULL);
    return st->size;
}

//顺序表的容量 
size_t capacity_seqtable(ST st){
    assert(st!=NULL);
    return st->cap;
}

//在顺序表末尾添加一个元素 e   返回值表示插入是否成功 
int push_back_seqtable(ST st,ElemType e){
    assert(st!=NULL);
    if(full_seqtable(st)){
        return FAILURE;
    }
    st->elems[st->size] = e;
    ++st->size;
    return SUCCESS;
}

//在指定位置pos(下标)插入一个元素e      
int insert_seqtable(ST st,size_t pos,ElemType e){
    assert(st!=NULL);
    if(full_seqtable(st) || pos > st->size){
        return FAILURE;
    }
    int i; 
    for(i=st->size;i>pos;--i){
        st->elems[i] = st->elems[i-1];
    }
    st->elems[pos] = e;
    ++st->size;
    return SUCCESS;
}

//删除指定位置的元素
int remove_seqtable(ST st,size_t pos,ElemType *pe){
    assert(st!=NULL);
    if(pos >= st->size){
        return FAILURE;
    }
    if(pe != NULL){
        *pe = st->elems[pos];
    }
    int i;
    for(i=pos+1;isize;++i){
        st->elems[i-1] = st->elems[i];
    }
    --st->size;
    return SUCCESS;
}

//删除最后一个位置的元素
int pop_back_seqtable(ST st,ElemType *pe){
    assert(st!=NULL);
    if(empty_seqtable(st)){
        return SUCCESS;
    }
    --st->size;
    if(pe != NULL){
        *pe = st->elems[st->size];
    }
    return SUCCESS;
}

//删除所有值等于e的元素
int delete_all_seqtable(ST st,ElemType e){
    assert(st!=NULL);
    int i;
    int cnt = 0;
    for(i=0;isize;++i){
        if(st->elems[i] == e){
            remove_seqtable(st,i,NULL);//删除i位置，把后面i+1位置元素填充到i位置 
            ++cnt;
            --i;
        } 
    }
    
    return cnt;  //返回删除的个数 
}

//删除第一个值等于e的元素
int delete_count_seqtable(ST st,ElemType e,size_t n){
    assert(st!=NULL && n!=0); 
    int i;
    for(i=0;isize;++i){
        if(st->elems[i] == e){
            --n;
            if(n == 0){
                return remove_seqtable(st,i,NULL);
            }
        }
    }
    return FAILURE;
}

//修改  更新 
int update_seqtable(ST st,size_t pos,ElemType ne){
    assert(st!=NULL);
    if(pos>=st->size){
        return FAILURE;
    }
    st->elems[pos] = ne;
}

//索引   根据位置获取对应的元素
ElemType *elem_of_seqtable(ST st,size_t pos){
    assert(st!=NULL);
    if(pos>=st->size){
        return NULL; 
    }
    return &st->elems[pos];
}

//查找   查找是否存在某个元素e
int find_seqtable(ST st,ElemType e,size_t n){
    assert(st!=NULL && n!=0);
    int i;
    for(i=0;isize;++i){
        if(st->elems[i] == e){
            if(--n == 0)
                return i;
        }
    }
    return -1;
}

size_t count_seqtable(ST st,ElemType e){
    assert(st!=NULL);
    int i;
    size_t cnt = 0;
    for(i=0;isize;++i){
        if(st->elems[i]==e){
            ++cnt;
        }
    }
    return cnt;
}
//查找   根据条件查找第n个满足条件的元素 
int search_seqtable(ST st,bool (*condition)(ElemType *pe),size_t n){
    assert(st!=NULL && condition!=NULL && n!=0);
    
    int i;
    for(i=0;isize;++i){
        if(condition(&st->elems[i])){
            if(--n == 0){
                return i;
            }
        }
    }
    return -1; 
}
 
//迭代   遍历 
void foreach_seqtable(ST st,void (*foreach)(ElemType *pe)){
    assert(st!=NULL && foreach!=NULL);
    int i;
    for(i=0;isize;++i){
        foreach(&st->elems[i]);
    } 
}

void clear_seqtable(ST st){
    assert(st!=NULL);
    st->size = 0;
}