动态顺序表的基本操作（c语言）

这是无自己写的动态顺序表练习，参考了很多前辈的代码，测试成功！！

#include <stdio.h>

#include <mallco.h>              // 使用malloc函数要包含这个文件
#include <assert.h>


#define INIT_CAPACITY 10  // 初始化时分配的容量


typedef struct seqlist{
    int *array;        // 存储空间的基地址
    int size;          // 有效元素个数
    int capacity;      // 当前分配的存储容量
}SEQLIST;


void seqlist_init(SEQLIST *list);          //初始化顺序表
void check_capacity(SEQLIST *list);        // 检查是否满

void push_front(SEQLIST *list, int value);  // 在顺序表前头部插入元素
void push_back(SEQLIST *list, int value);   // 在顺序表尾部插入元素
void insert_list(SEQLIST *list, int pos, int value);        // 在pos这个位置插入元素

void pop_front(SEQLIST *list);              // 删除顺序表第一个元素
void pop_back(SEQLIST *list);               // 删除顺序表最后一个元素

void list_printf(SEQLIST *list);            // 遍历顺序表
void destroy_list(SEQLIST *list);           // 摧毁顺序表
void list_cleardata(SEQLIST *list);         // 清空顺序表的数据


int main(void)
{
    SEQLIST list;
    
    seqlist_init(&list);
    push_front(&list, 3);
    push_front(&list, 2);
    push_front(&list, 1);
//    list_printf(&list);
    
    push_back(&list, 3);
    push_back(&list, 2);
    push_back(&list, 1);
    pop_back(&list);
    pop_front(&list);
    insert_list(&list, 3, 4);
    list_printf(&list);
    
    return 0;
}


// 初始化顺序表

void seqlist_init(SEQLIST *list)
{
    assert(list);   // 断言：判断list是否为空
    
    list->array = (int *)malloc(INIT_CAPACITY * sizeof(int)); // 分配一断内存，容量为 INIT_CAPACITY个int的大小
    assert(list->array);               // 断言：判断aray是否为空
    list->size = 0;                    // 没有赋值之前有效元素个数为0
    list->capacity = INIT_CAPACITY;    // 容量
}


// 判断顺序表是否以满，如果满了，增加顺序表的容量

void check_capacity(SEQLIST *list)
{
    assert(list);    // 判断传入的指针是否为空
    
    if (list->size == list->capacity)
    {
         // 重新分配一块内存，但是之前的数据不变
        list->array = (int *)realloc(list->array, (2 * list->capacity * sizeof(int))); 
        assert(list);            // 判断是否分配成功
        list->capacity *= 2;     // 容量翻倍
    }
}


// 在顺序表前插入数据    
void push_front(SEQLIST *list, int value)
{
    int i;
    
    assert(list);            // 判断传入的是否为空
    check_capacity(list);    // 在执行插入之前先判断顺序表是否以满，如果满了，增加顺序表的容量
    
    // 将所有元素向后移动一位
    for(i=list->size; i>=0; i--)
    {
        list->array[i] = list->array[i-1];
    }
    list->array[0] = value;  // 将插入的值赋给第一个元素
    list->size++;            // 有效元素个数 +1    
}


// 在顺序表尾部插入数据    
void push_back(SEQLIST *list, int value)
{
    assert(list);    // 判断传入的是否为空
    
    check_capacity(list);  // 在执行插入之前先判断顺序表是否以满，如果满了，增加顺序表的容量
    
    list->array[list->size] = value; // size记录了当前有效元素的个数，而数组从0开始，array[list->size]处在顺序表最后一个元素的位置+1
    list->size++;           // 插入后，有效元素个数+1
}


// 在顺序表第pos个位置插入数据    
void insert_list(SEQLIST *list, int pos, int value)
{
    int i;
    
    assert(list);  // 判断传入的指针是否为空
    if (pos > list->size+1 && pos < 0) 
    {
        printf("非法操作！！\n");
        return;    
    }
    

    // 将第pos个位置之后的数据往后移动一位
    for (i=list->size; i>=pos; i--)
    {
        list->array[i] = list->array[i-1];    
    }
    
    list->array[pos-1] = value;
    list->size++;
}


// 删除头部数据

void pop_front(SEQLIST *list)
{
    int i = 0;
    
    assert(list);    // 判断传入的是否为空
    
    if (list->size == 1)
    {
        list->size = 0;
    }
    else
    {
        for (i=0; i<list->size; i++)
        {
            // 将后面的赋值给前面的，第0个元素的数据就不管了(第0个数据被覆盖)
            // 第1个元素的数据给第0个数据  第2个元素的数据给第1个数据 ...
            list->array[i] = list->array[i+1];  
        }
    }
    list->size--; // 有效数据的个数减1
}


void pop_back(SEQLIST *list)
{
    assert(list);
    
    if (list->size == 0)
    {
        return;    
    }
    else
    {
        list->size--;
    }
}

void list_printf(SEQLIST *list)
{
    int i;
    
    for (i=0; i<list->size; i++)
    {
        printf("%d  \n", list->array[i]);
    }
}

void destroy_list(SEQLIST *list)
{
    free(list->array);
    
    list->size = 0;
    list->capacity = 0;
}


void list_cleardata(SEQLIST *list)
{
    list->size = 0;
}