C数据结构-线性表之顺序表

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/water_3700348/article/details/78130389

线性表之顺序表

顺序表使用C语言的原生数组作为存储结构，用户指定数组的大小，动态的申请堆空间。动态设计的好处比事先用宏定义规定大小更加灵活，而且支持顺序表的重置大小操作。使得使用顺序表的人拥有更大的灵活性，节省运行内存。顺序表结构体的定义使用了柔性数组，这一点使得我们在操作顺序表数据数组时变得相当简单。值得讲解的有几个操作：

1. 线性表的重置大小

int seq_list_resize(seq_list *plist, int size);

重置大小可以是容量变大或者变小，如果重置的大小与原数组的大小一致，那将什么都不做。重置大小之后将会复制旧数组中的内容到新的数组中，实质就是调用了realloc函数进行重置和复制工作。如果重置的大小小于原来的大小，那么将发生数据截断；如果重置的大小大于原来的大小则原来数组中的所有元素会被保留。

2. 线性表的清空

int seq_list_clear(seq_list *plist);

清空数据表的操作，实际上只是将顺序表的长度值设置为0，并不实际清除数组中的内容，因为这么做毫无意义。

#ifndef SEQLIST_H
#define SEQLIST_H

#ifndef NULL
#define NULL 0
#endif


/* 元素类型 */
typedef int elem_t;

/* 顺序表结构体 */
typedef struct _tag_list
{
    int length;//顺序表长度
    int capacity;//顺序表的最大容量
    elem_t data[];

}seq_list;

/*
 * 顺序表初始化
 * @param size 顺序表的大小
 * @param return 顺序表的指针
 */
seq_list *seq_list_init(int size);

/*
 * 插入元素
 * @param plist 顺序表指针
 * @param i 插入位置的索引
 * @param e 插入的元素指针
 * @return 1:成功 0:失败
 */
int seq_list_insert(seq_list *plist,int i,elem_t *pe);

/*
 * 删除元素
 * @param plist 顺序表指针
 * @param i 删除位置的索引
 * @param pe 存储被删除元素值的指针
 * @return 1:成功 0:失败
 */
int seq_list_delete(seq_list *plist,int i,elem_t *pe);

/*
 * 获取元素
 * @param plist 顺序表指针
 * @param i 获取位置的索引
 * @param pe 存储元素值的指针
 * @return 1:成功 0:失败
 */
int seq_list_get(seq_list *plist,int i,elem_t *pe);

/*
 * 重置顺序表大小
 * @param plist 顺序表指针
 * @param size 重置后顺序表的最大容量
 * @param return 1:成功 0:失败
 */
int seq_list_resize(seq_list *plist, int size);

/*
 * 判断顺序表是否为空
 * @param plist 顺序表指针
 * @return 1:为空 0:不为空
 * @return 1:为空 0:不为空 -1:出错
 */
int seq_list_is_empty(seq_list *plist);

/*
 * 获取顺序表的长度
 * @param plist 顺序表指针
 * @return 长度
 */
int seq_list_length(seq_list *plist);

/*
 * 获取顺序表的最大容量
 * @param plist 顺序表指针
 * @return 长度
 */
int seq_list_max_size(seq_list *plist);

/*
 * 清空顺序表
 * @param plist 顺序表指针
 * @param return 1：成功 0:失败
 */
int seq_list_clear(seq_list *plist);

/*
* 销毁顺序表
*/
int seq_list_destroy(seq_list *plist);


#endif // SEQLIST

#include "SeqList.h"
#include "malloc.h"

/*
 * 顺序表初始化
 * @param size 顺序表的大小
 * @param return 顺序表的指针
 */
seq_list *seq_list_init(int size)
{
    seq_list *plist = (seq_list *)malloc(sizeof(seq_list) + sizeof(elem_t) * size);

    if(plist)
    {
        plist->length = 0;
        plist->capacity = size;
    }

    return plist;

}

/*
 * 插入元素
 * @param plist 顺序表指针
 * @param i 插入位置的索引
 * @param e 插入的元素指针
 * @return 1:成功 0:失败
 */
int seq_list_insert(seq_list *plist,int i,elem_t *pe)
{
    //合法性检查
    int ret = ( (plist != NULL) && (i >= 0) && (i <= plist->length) && (plist->length + 1 <= plist->capacity) );

    if(ret)
    {
        int pos =0;
        //从后往前逐个将元素后移
        for(pos = plist->length;pos > i;pos--)
        {
            plist->data[pos] = plist->data[pos - 1];
        }
        //将元素插入
        plist->data[i] = *pe;
        plist->length++;
    }

    return ret;
}

/*
 * 删除元素
 * @param plist 顺序表指针
 * @param i 删除位置的索引
 * @param pe 存储被删除元素值的指针
 * @return 1:成功 0:失败
 */
int seq_list_delete(seq_list *plist,int i,elem_t *pe)
{
    //合法性检查
    int ret = ( (plist != NULL) && (i >= 0) && (i < plist->length) );

    if(ret)
    {
        int pos = 0;
        //保存被删除元素的值
        *pe = plist->data[i];
        //从被删除索引处开始，将后一位的数据往前移动
        for(pos = i;pos < plist->length -1;pos++)
        {
            plist->data[pos] = plist->data[pos + 1];
        }
        plist->length--;


    }

    return ret;
}

/*
 * 获取元素
 * @param plist 顺序表指针
 * @param i 获取位置的索引
 * @param pe 存储元素值的指针
 * @return 1:成功 0:失败
 */
int seq_list_get(seq_list *plist,int i,elem_t *pe)
{
    //合法性检查
    int ret = ( (plist != NULL) && (i >= 0) && (i < plist->length) );

    if(ret)
    {
        //保存元素的值
        *pe = plist->data[i];

    }

    return ret;
}

/*
 * 判断顺序表是否为空
 * @param plist 顺序表指针
 * @return 1:为空 0:不为空 -1:出错
 */
int seq_list_is_empty(seq_list *plist)
{
    int ret = -1;

    if(plist != NULL)
    {
        ret = (plist->length == 0);
    }
    return ret;
}

/*
 * 获取顺序表的长度
 * @param plist 顺序表指针
 * @return 长度,-1出错
 */
int seq_list_length(seq_list *plist)
{
    int ret = -1;

    if(plist != NULL)
    {
        ret = plist->length;
    }

    return ret;
}

/*
 * 重置顺序表大小
 * @param plist 顺序表指针
 * @param size 重置后顺序表的最大容量
 * @param return 1:成功 0:失败
 */
int seq_list_resize(seq_list *plist, int size)
{
    int ret = (plist != NULL && size >0);

    if(ret && (plist->length != size) )
    {
        int length = plist->length;
        length = (size > length ? length : size);
        //重新申请空间,realloc会自动释放原空间
        seq_list *p = realloc(plist,sizeof(seq_list) + sizeof(elem_t) * size);
        if(p != NULL)
        {
            plist = p;
            plist->length = length;
            plist->capacity = size;
        }else
        {
            ret = 0;
        }
    }

    return ret;
}

/*
 * 获取顺序表的最大容量
 * @param plist 顺序表指针
 * @return 长度，-1出错
 */
int seq_list_max_size(seq_list *plist)
{
    int ret = -1;

    if(plist != NULL)
    {
        ret = plist->capacity;
    }

    return ret;
}

/*
 * 清空顺序表
 * @param plist 顺序表指针
 * @param return 1：成功 0:失败
 */
int seq_list_clear(seq_list *plist)
{
    int ret = (plist != NULL);

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

    return ret;
}

/*
* 销毁顺序表
*/
int seq_list_destroy(seq_list *plist)
{
    int ret = (plist != NULL);

    if(ret)
    {
        free(plist);
        plist = NULL;
    }

    return ret;
}