SeqList.h

#ifndef SEQ_LIST_H
#define SEQ_LIST_H

typedef void SeqListNode;
typedef void SeqList;

/*
 * 创建顺序表
 * @param capacity 顺序表的最大容量
 * @return 返回顺序表的指针
 */
SeqList* SeqList_Create(unsigned int capacity);

/*
 * 销毁顺序表
 * @param list 顺序表的指针
 */
void SeqList_Destroy(SeqList *list);

/*
 * 清空顺序表
 * @param list 顺序表的指针
 */
void SeqList_Clear(SeqList *list);

/*
 * 向顺序表pos位置处插入元素
 * @param list 顺序表指针
 * @param node 元素指针
 * @param pos 插入的索引
 */
int SeqList_Insert(SeqList *list,SeqListNode *node,int pos);

/*
 * 获取顺序表中索引位置处的元素
 * @param list   顺序表指针
 * @param pos   顺序表索引值
 * @param return 元素指针
 */
SeqListNode* SeqList_Get(SeqList *list,int pos);

/*
 * 删除顺序表中索引位置处的值
 * @param list 顺序表的指针
 * @param pos   顺序表索引
 * @param return 非0表示删除成功
 */
int SeqList_Remove(SeqList *list,int pos);

/*
 * 获取顺序表当前已存储元素的个数
 * @param list 顺序表的指针
 * @return 顺序表中已存储元素的个数
 */
int SeqList_Length(SeqList *list);

/*
 * 获取顺序表最大可存储元素的个数
 * @param list 顺序表的指针
 * @return 顺序表最大可存储元素的个数
 */
int SeqList_Capacity(SeqList *list);


#endif // SEQLIST_H

SeqList.c

#include "SeqList.h"
#include 

typedef unsigned int TSeqListNode;  //顺序表节点

typedef struct _SeqList
{
    unsigned int length;    //顺序表已存储元素的个数
    unsigned int capacity;  //顺序表最大可存储元素的个数
    TSeqListNode *element[];//顺序表节点柔性数组
}TSeqList;

/*
 * 创建顺序表
 * @param capacity 顺序表的最大容量
 * @return 返回顺序表的指针
 */
SeqList* SeqList_Create(unsigned int capacity)
{
    TSeqList *list = 0;
    //创建一个可容纳SeqList结构体与柔性节点的空间
    int size = sizeof(TSeqList) + sizeof(TSeqListNode) * capacity;
    list = (TSeqList *)malloc(size);

    if(list != 0)
    {
        list->length = 0;
        list->capacity = capacity;
    }

    return list;
}

/*
 * 销毁顺序表
 * @param list 顺序表的指针
 */
void SeqList_Destroy(SeqList *list)
{
    free(list);
}

/*
 * 清空顺序表
 * @param list 顺序表的指针
 */
void SeqList_Clear(SeqList *list)
{
    TSeqList *s_list = (TSeqList *)list;

    if(s_list != 0)
    {
        s_list->length = 0;
    }
}

/*
 * 向顺序表pos位置处插入元素
 * @param list 顺序表指针
 * @param node 元素指针
 * @param pos 插入的索引
 * @param return 返回非0表示插入成功
 */
int SeqList_Insert(SeqList *list,SeqListNode *node,int pos)
{
    int i;
    //判断顺序表指针和被插入元素的指针是否为空
    int ret = ((list != 0) && (node != 0));

    TSeqList *s_list = (TSeqList *)list;
    TSeqListNode *s_node = (TSeqListNode *)node;

    //判断插入的索引是否合法,数组空间是否剩余
    ret = ((pos >= 0) && (pos <= s_list->length) && (s_list->length + 1 <= s_list->capacity));


    if(ret)
    {//参数合法，可以插入
        //从最后一个开始把数据往后挪
        for(i = s_list->length;i > pos;i-- )
        {
            s_list->element[i] = s_list->element[i -1];
        }
        s_list->element[i] = s_node;
        s_list->length++;
    }

    return ret;
}

/*
 * 获取顺序表中索引位置处的元素
 * @param list   顺序表指针
 * @param pos   顺序表索引值
 * @param return 元素指针
 */
SeqListNode* SeqList_Get(SeqList *list,int pos)
{
    SeqListNode *s_node = 0;
    TSeqList *s_list = (TSeqList *)list;

    if( (s_list != 0) && (pos >= 0) && (pos < s_list->length）)
    {
        s_node = s_list->element[pos];
    }

    return s_node;
}

/*
 * 删除顺序表中索引位置处的值
 * @param list 顺序表的指针
 * @param pos   顺序表索引
 * @param return 顺序表中索引位置处元素的值
 */
int SeqList_Remove(SeqList *list,int pos)
{
    int i;
    TSeqList *s_list = (TSeqList *)list;
    int ret = ((s_list != 0) && (pos >= 0)  && (pos < s_list->length));

    if(ret)
    {
       for(i = pos + 1;i < s_list->length;i++)
       {
           s_list->element[i -1] = s_list->element[i];
       }
       s_list->length--;
    }

    return ret;
}

/*
 * 获取顺序表当前已存储元素的个数
 * @param list 顺序表的指针
 * @return 顺序表中已存储元素的个数
 */
int SeqList_Length(SeqList *list)
{
    TSeqList *s_list = (TSeqList *)list;
    int ret = -1;

    if(s_list != 0)
    {
        ret = s_list->length;
    }

    return ret;
}

/*
 * 获取顺序表最大可存储元素的个数
 * @param list 顺序表的指针
 * @return 顺序表最大可存储元素的个数
 */
int SeqList_Capacity(SeqList *list)
{
    TSeqList *s_list = (TSeqList *)list;
    int ret = (s_list != 0);

    if(ret)
    {
        ret = s_list->capacity;
    }

    return ret;
}