动态顺序表基本操作

SeqlistD.h文件

typedef int DataType;
typedef unsigned int size_t;

typedef struct SeqListD
{
    DataType* _array;
    size_t _capacity; // 底层空间的大小 
    size_t _size; // 有效元素的个数 
}SeqListD, *PSeqListD;


void SeqListDInit(PSeqListD pSeq);//初始化
void SeqListDPushBack(PSeqListD pSeq, DataType data);//尾插
void SeqListDPopBack(PSeqListD pSeq);///尾删
int SeqListDSize(PSeqListD pSeq);//大小
// 清空顺序表中的所有元素，注意不改变底层空间的大小 
void SeqListDClear(PSeqListD pSeq);
int SeqListDCapacity(PSeqListD pSeq);//扩大容量  

// 销毁顺序表 
void SeqListDDestroy(PSeqListD pSeq);

// 检测顺序表是否需要增容 
int CheckCapacity(PSeqListD pSeq); 

//打印
void PrintSeqlist(PSeqListD pSeq);

int SeqListDEmpty(PSeqListD pSeq);//判空

SeqlistD.c文件

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include"SeqlistD.h"


void SeqListDInit(PSeqListD pSeq)//初始化
{
    if (NULL == pSeq)
        return;
    pSeq->_array = (DataType *)malloc(3 * sizeof(DataType));
    //assert(pSeq->_array);
    if (NULL == pSeq->_array)
        return;
    pSeq->_size = 0;
    pSeq->_capacity = 3;
}

// 检测顺序表是否需要增容 
int CheckCapacity(PSeqListD pSeq)
{
    if (NULL == pSeq)
        return 0;
    if (pSeq->_size >= pSeq->_capacity)
    {
        //扩容
        size_t newCapacity = pSeq->_capacity * 2;
        DataType* pTmp = (DataType*)malloc(newCapacity * sizeof(DataType));
        if (NULL == pTmp)
            return 0;
        //将原空间元素移到新空间
        memcpy(pTmp, pSeq->_array, pSeq->_size*sizeof(DataType));
        free(pSeq->_array);
        pSeq->_array = pTmp;
        pSeq->_capacity = newCapacity;
    }
    return 1;
}


void SeqListDPushBack(PSeqListD pSeq, DataType data)//尾插
{
    if (NULL == pSeq)
        return;
    if (!CheckCapacity(pSeq))
        return;
    pSeq->_array[pSeq->_size++] = data;
}

void SeqListDPopBack(PSeqListD pSeq)///尾删
{
    if (NULL == pSeq)
        return;
    if (pSeq->_size == 0)
    {
        printf("NULL!\n");
        return;
    }
    pSeq->_size--;
}

int SeqListDEmpty(PSeqListD pSeq)//判空
{
    return 0 == pSeq->_size;
}

int SeqListDSize(PSeqListD pSeq)//求动态顺序表的长度
{
    return pSeq->_size;
}

int SeqListDCapacity(PSeqListD pSeq)//求动态顺序表的容量  
{
    return pSeq->_capacity;
}

// 清空顺序表中的所有元素，注意不改变底层空间的大小 
void SeqListDClear(PSeqListD pSeq)
{
    pSeq->_size = 0;
}

// 销毁顺序表 
void SeqListDDestroy(PSeqListD pSeq)
{
    if(pSeq->_array)
    {
        free(pSeq->_array);
        pSeq->_capacity = 0;
        pSeq->_size = 0;
    }
}

void PrintSeqlist(PSeqListD pSeq)//打印
{
    int i = 0;
    for (; i < pSeq->_size; ++i)
    {
        printf("%d ", pSeq->_array[i]);
    }
    printf("\n");
}

test.c文件

#define _CRT_SECURE_NO_WARNINGS

#include"SeqlistD.h"

void TestSeqListD()
{
    SeqListD s;
    SeqListDInit(&s);
    SeqListDPushBack(&s, 1);
    SeqListDPushBack(&s, 2);
    SeqListDPushBack(&s, 3);
    PrintSeqlist(&s);

    printf("size = %d\n", SeqListDSize(&s));
    printf("capacity = %d\n", SeqListDCapacity(&s));

    SeqListDPushBack(&s, 4);
    printf("size = %d\n", SeqListDSize(&s));
    printf("capacity = %d\n", SeqListDCapacity(&s));

    SeqListDClear(&s);
    printf("size = %d\n", SeqListDSize(&s));
    printf("capacity = %d\n", SeqListDCapacity(&s));

    SeqListDDestroy(&s);
    printf("size = %d\n", SeqListDSize(&s));
    printf("capacity = %d\n", SeqListDCapacity(&s));
}
int main()
{
    TestSeqListD();
    system("pause");
    return 0;
}

结果