动态顺序表c语言实现

主要操作结构体中的指针，在init函数里对指针进行内存开辟，checkCapacity函数在每次插入之前检查一遍，如果可用空间没有了，就开辟当前最大容量的两倍。其他操作与静态顺序表无大区别。

seqList.h

#pragma once
#define DataType int

typedef struct seqList {
    DataType * array;
    int size;           //当前元素数
    int capicity;         //最大容量
}*PSeqListD, seqListD;

void SeqListDInit(PSeqListD ps, int capacity);
void SeqListDPushBack(PSeqListD ps, DataType data);
void SeqListDPopBack(PSeqListD ps);
void SeqListDInsert(PSeqListD ps, int pos, DataType data);
void SeqListDErase(PSeqListD ps, int pos);

// 获取元素个数 
int SeqListDSize(PSeqListD ps);
// 获取顺序表的容量 
int SeqListDCapacity(PSeqListD ps);
int SeqListDEmpty(PSeqListD ps);
// 将顺序表中的元素清空 注意：不改变顺序表空间的大小 
void SeqListDClear(PSeqListD ps);
void SeqListDDestroy(PSeqListD * ps);
// 对顺序表进行增容 
int CheckCapacity(PSeqListD ps);

test.c

#include "seqListD.h"

int main()
{
    seqListD seq;
    SeqListDInit(&seq, 5);
    SeqListDPushBack(&seq, 1);
    SeqListDInsert(&seq, 0, 2);
    SeqListDInsert(&seq, 0, 3);
    SeqListDInsert(&seq, 3, 4);
    SeqListDInsert(&seq, 2, 7);
    SeqListDPushBack(&seq, 9);
    SeqListDErase(&seq, 2);
}

seqList.c

#include "seqListD.h"
#include <stdio.h>
#include <malloc.h>
void SeqListDInit(PSeqListD ps, int capacity)
{
    if (NULL == ps || capacity < 0) {
        return;
    }
    ps->size = 0;
    ps->capicity = capacity;
    ps->array = (DataType*)malloc(sizeof(DataType) * capacity);
    if (ps->array == NULL) {
        printf("分配内存失败");
    }
}

void SeqListDDestroy(PSeqListD ps)
{
    if (NULL == ps) {
        return;
    }
    free(ps->array);
    ps->array = NULL;
}
void SeqListDPushBack(PSeqListD ps, DataType data)
{
    if (NULL == ps || NULL == ps->array) {
        return;
    }
    if (CheckCapacity(ps)) {
        ps->array[ps->size] = data;
        ps->size++;
    }
}
void SeqListDPopBack(PSeqListD ps)
{
    if (NULL == ps || NULL == ps->array) {
        return;
    }
    if (ps->size == 0) {
        printf("无可删除的");
        return;
    }
    ps->size--;
}
void SeqListDInsert(PSeqListD ps, int pos, DataType data)
{
    if (NULL == ps || NULL == ps->array) {
        return;
    }
    if (CheckCapacity(ps)) {
        int i = 0;
        for (i = ps->size; i > pos; i--) {
            ps->array[i] = ps->array[i - 1];
        }
        ps->array[pos] = data;
        ps->size++;
    }
}
void SeqListDErase(PSeqListD ps, int pos) {

    if (NULL == ps || NULL == ps->array) {
        return;
    }
    if (ps->size == 0) {
        printf("没有元素可以删\n");
        return;
    }
    int i = 0;
    for (i = pos; i < ps->size - 1; i++) {
        ps->array[i] = ps->array[i + 1];
    }
    ps->size--;
}

// 对顺序表进行增容 
int CheckCapacity(PSeqListD ps)
{
    if (NULL == ps) {
        return 0;
    }
    //防止新空间开辟失败旧空间丢失的情况
    if (ps->size == ps->capicity) {
        DataType * newBase = (PSeqListD)realloc(ps->array, 2 * ps->capicity * sizeof(DataType));
        if (newBase == NULL) {
            printf("扩容失败");
            return 0;
        }
        ps->array = newBase;
        ps->capicity *= 2;
    }
    return 1;
}
// 获取元素个数 
int SeqListDSize(PSeqListD ps)
{
    if (NULL == ps) {
        return -1;
    }
    return ps->size;
}

// 获取顺序表的容量 
int SeqListDCapacity(PSeqListD ps)
{
    if (NULL == ps) {
        return -1;
    }
    return ps->capicity;
}

int SeqListDEmpty(PSeqListD ps)
{
    if (NULL == ps) {
        return -1;
    }
    return ps->size ? 1 : 0;
}

// 将顺序表中的元素清空 注意：不改变顺序表空间的大小 
void SeqListDClear(PSeqListD ps)
{
    if (NULL == ps) {
        return;
    }
    ps->size = 0;
}