顺序表C语言

顺序表

SqList.h文件

#ifndef SQLIST_H
#define SQLIST_H

typedef unsigned short int ElemType;    //ElemType类型根据实际情况而定

typedef struct
{
    ElemType* elem;                     //数组存储数据，最大值为MAXSIZE
    unsigned int length;                //线性表当前长度（当前元素个数）
    unsigned int MaxSize;               //存储空间最大值
}SqList;                                //顺序表的结构类型

/*制作一个空的顺序表*/
void SqList_Init(SqList* L,unsigned int size);
/*追加元素*/
void SqList_Append(SqList* L, ElemType e);
/*遍历顺序表*/
void SqList_Traverse(SqList L);
/*插入元素：在下标 i 插入一个元素e */
void SqList_Insert(SqList* L, unsigned int i, ElemType e);
/*删除元素：删除下标 i 对应的元素 */
ElemType SqList_Delete(SqList* L, unsigned int i);
/*清空顺序表*/
void SqList_Clear(SqList* L);
/*销毁顺序表*/
void SqList_Destroy(SqList* L);

#endif // SQLIST_H

SqList.c文件

#include "SqList.h"

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

static const unsigned int INCREMENT = 5;       //存储空间增量

/*制作一个空的顺序表，分配内存*/
void SqList_Init(SqList* L, unsigned int size)
{
    L->length = 0;
    L->MaxSize = size;
    L->elem = calloc(sizeof(ElemType), L->MaxSize);
}

/*追加元素*/
void SqList_Append(SqList* L, ElemType e)
{
    L->elem[L->length] = e;
    L->length += 1;

    if (L->length == L->MaxSize)    //如果存储已满，则增加存储空间
    {
        L->MaxSize += INCREMENT;
        ElemType* temp = realloc(L->elem,sizeof(ElemType) * L->MaxSize);
        if (temp != NULL)           //防止重新分配内存失败后，原地址丢失
        {
            L->elem = temp;
        }
    }
}
/*遍历顺序表*/
void SqList_Traverse(SqList L)
{
    assert(L.length != 0);   //断言，顺序表不空

    for (unsigned int i = 0; i  <  L.length; i++)
    {
        printf("%d ", L.elem[i]);
    }
    printf("\n");
}

/*插入元素：在下标 i 插入一个元素e */
void SqList_Insert(SqList* L, unsigned int i, ElemType e)
{
    assert(L->length != 0);                 //断言，顺序表不空
    assert(i >= 0 && i < L->length);        //断言，0 <= i < length

     for (unsigned int j = L->length; j > i ; j--)
     {
         L->elem[j] = L->elem[j - 1];          //所有元素向后移动一个元素
     }
     L->elem[i] = e;
     L->length += 1;

     if (L->length == L->MaxSize)             //如果存储已满，则重新分配存储空间
     {
         L->MaxSize += INCREMENT;
         ElemType* temp = realloc(L->elem, sizeof(ElemType) * L->MaxSize);
         if (temp != NULL)                   //防止重新分配内存失败后，原地址丢失
         {
             L->elem = temp;
         }
     }
}
/*删除元素：删除下标 i 对应的元素 */
ElemType SqList_Delete(SqList* L, unsigned int i)
{
    assert(L->length != 0);                   //断言，顺序表不空
    assert(i >= 0 && i < L->length);          //断言，0 <= i < length

    ElemType e = L->elem[i];
    for (unsigned int j = i; j <= L->length; j++)
    {
        L->elem[j] = L->elem[j + 1];      //所有元素向前移动一个元素
    }
    L->length -= 1;
    return e;
}

/*清空顺序表*/
void SqList_Clear(SqList* L)
{
    assert(L->length != 0);   //断言，顺序表不空

    for (unsigned int i = 0; i < L->length; i++)
    {
        L->elem[i] = 0;             //顺序表内所有元素都为0
    }
    L->length = 0;
}
/*销毁顺序表*/
void SqList_Destroy(SqList* L)
{
    assert(L->elem != NULL);

    free(L->elem);
    L->elem = NULL;
    L->length = 0;
    L->MaxSize = 0;
}

/*测试*/
void SqList_Test(void)
{
    SqList list;
    SqList_Init(&list, 4);      
    SqList_Append(&list, 0);
    SqList_Append(&list, 1);
    SqList_Append(&list, 2);
    SqList_Append(&list, 3);
    SqList_Append(&list, 4);
    SqList_Traverse(list);
    SqList_Insert(&list, 1, 9);
    SqList_Traverse(list);
    SqList_Delete(&list, 0);
    SqList_Traverse(list);
    SqList_Append(&list, 6);
    list.elem[0] = 100;
    printf("%d\n", list.MaxSize);
    SqList_Traverse(list);
    SqList_Destroy(&list);
    printf("%p\n", list.elem);
}

测试：main.c文件

#include <stdio.h>
#include "SqList.h"

int main()
{
	SqList_Test(void);
	return 0;
}

测试结果