顺序表（SeqList）（动态）

实现功能

SeqListInit ———————初始化

SeqListDestory ————摧毁

SeqListPushFront ————头插

SeqListPushBack ————尾插

SeqListPopBack ————尾删

SeqListPopFront ————头删

SeqListInsert ——————任意位置插入

SeqListErase ——————任意位置删除

SeqListFind_By_Val ———查找

SeqListUpdata——————修改

SeqListPrint ———————打印

CheckEmpty ———————判断顺序表是否为空

SeqList.h

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1

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

#define DEFAULT_CAPACITY 3

typedef int SLDataType;

typedef struct
{
    SLDataType* data;
    size_t size;
    size_t capacity;
}SeqList;

extern void SeqListInit(SeqList* pList);//初始化
extern void SeqListDestory(SeqList* pList);//销毁
extern void SeqListPushFront(SeqList* pList, SLDataType n);//头插
extern void SeqListPushBack(SeqList* pList, SLDataType n);//尾插
extern void SeqListPopBack(SeqList* pList);//尾删
extern void SeqListPopFront(SeqList* pList);//头删
extern void SeqListInsert(SeqList* pList, int pos, SLDataType x);//任意位置插入
extern void SeqListErase(SeqList* pList, int pos);//任意位置删除
extern int SeqListFind_By_Val(SeqList* pList, SLDataType x);//查找
extern void SeqListUpdata(SeqList* pList, int pos, SLDataType x);//修改
extern void SeqListPrint(SeqList* pList);//打印
extern bool CheckEmpty(SeqList* pList);//判断顺序表是否为空

SeqList.c

#include "SeqList.h"

void CheckOccupancy(SeqList* pList)
{
    if (pList->size == pList->capacity)
    {
        SLDataType* ptr = (SLDataType*)realloc(pList->data, sizeof(SLDataType) * pList->capacity * 2);
        if (!ptr)
        {
            perror("realloc");
            exit(-1);
        }
        pList->data = ptr;
        pList->capacity *= 2;
    }
}

bool CheckEmpty(SeqList* pList)
{
    return (pList->size) ? false : true;
}

void SeqListInit(SeqList* pList)
{
    pList->data = (SLDataType*)malloc(sizeof(SLDataType) * DEFAULT_CAPACITY);
    if (!pList->data)
    {
        perror("SeqListInit");
        return;
    }
    pList->capacity = DEFAULT_CAPACITY;
    pList->size = 0;
}


void SeqListDestory(SeqList* pList)
{
    free(pList->data);
    pList->data = NULL;
    pList->size = 0;
    pList->capacity = 0;
}


void SeqListPushFront(SeqList* pList, SLDataType n)
{
    CheckOccupancy(pList);
    pList->size++;
    for (int i = pList->size - 1; i > 0; --i)
    {
        pList->data[i] = pList->data[i - 1];
    }
    pList->data[0] = n;
}


void SeqListPushBack(SeqList* pList, SLDataType n)
{
    CheckOccupancy(pList);
    pList->size++;
    pList->data[pList->size - 1] = n;
}


void SeqListPopBack(SeqList* pList)
{
    if (CheckEmpty(pList))
    {
        printf("SeqList is empty!\n");
    }
    else
        pList->size--;
}


void SeqListPopFront(SeqList* pList)
{
    if (CheckEmpty(pList))
    {
        printf("SeqList is empty!\n");
        return;
    }
    for (int i = 0; i < pList->size - 1; ++i)
    {
        pList->data[i] = pList->data[i + 1];
    }
    pList->size--;
}


void SeqListInsert(SeqList* pList, int pos, SLDataType x)
{
    CheckOccupancy(pList);
    if (pos < 0 || pos > pList->size)
    {
        printf("The position to insert is illegal");
        return;
    }
    for (int i = pList->size; i > pos; --i)
    {
        pList->data[i] = pList->data[i - 1];
    }
    pList->data[pos] = x;
    pList->size++;
}


void SeqListErase(SeqList* pList, int pos)
{
    if (CheckEmpty(pList))
    {
        printf("SeqList is empty!\n");
        return;
    }
    for (int i = pos; i < pList->size - 1; ++i)
    {
        pList->data[i] = pList->data[i + 1];
    }
    pList->size--;
}


int SeqListFind_By_Val(SeqList* pList, SLDataType x)
{
    if (CheckEmpty(pList))
    {
        printf("SeqList is empty!\n");
        return -1;
    }
    int i;
    for (i = 0; i < pList->size; ++i)
    {
        if (pList->data[i] == x)
        {
            break;
        }
    }
    if (i == pList->size)
    {
        printf("Can't find it!\n");
        return -1;
    }
    else
    {
        printf("Got it, the index is %d !\n", i);
        return i;
    }
}


void SeqListUpdata(SeqList* pList, int pos, SLDataType x)
{
    if (pos<0 || pos>pList->size)
    {
        printf("The position is illegal!\n");
        return;
    }
    pList->data[pos] = x;
}


void SeqListPrint(SeqList* pList)
{
    if (CheckEmpty(pList))
    {
        printf("SeqList is empty!Can't print it!\n");
        return;
    }
    for (int i = 0; i < pList->size; ++i)
    {
        printf("%d ", pList->data[i]);
    }
    printf("\n");
}

test.c

#include "SeqList.h"


void main()
{
        SeqList seq;
        SeqListInit(&seq);
        SeqListPushFront(&seq, 11);
        SeqListPushFront(&seq, 22);
        SeqListPushFront(&seq, 33);
        SeqListPrint(&seq);

        SeqListPopFront(&seq);
        SeqListPopFront(&seq);
        SeqListPopFront(&seq);
        SeqListPrint(&seq);

        SeqListPushBack(&seq, 44);
        SeqListPushBack(&seq, 55);
        SeqListPushBack(&seq, 66);
        SeqListPushBack(&seq, 77);
        SeqListPrint(&seq);

        SeqListPopBack(&seq);
        SeqListPopBack(&seq);
        SeqListPopBack(&seq);
        SeqListPrint(&seq);

        SeqListInsert(&seq, 0, 333);
        SeqListInsert(&seq, 1, 222);
        SeqListInsert(&seq, 2, 111);
        SeqListInsert(&seq, 3, 99);
        SeqListPrint(&seq);

        SeqListErase(&seq, 2);
        SeqListErase(&seq, 1);
        SeqListErase(&seq, 0);
        SeqListPrint(&seq);

        int index = SeqListFind_By_Val(&seq, 99);
        SeqListUpdata(&seq, index, 888);
        SeqListPrint(&seq);

        SeqListDestory(&seq);
}