C语言实现动态顺序表

1、用于存放声明的头文件

#pragma once  //避免重复引入头文件，作用于预编译指令几乎相同

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <malloc.h>

typedef int DataType;
typedef struct SepList_d
{
    DataType *pData;       //顺序表存储户
    size_t size;         //顺序表中元素个数
    size_t capacity;     //顺序表的容量（可以容纳的元素的个数)
}SeqList, *PSeqList;

//所有函数中出现的某个元素的位置，都指的是它是顺序表第几个元素，而不是它在顺序表中的下标值
// 初始化顺序表
void InitSeqListD(PSeqList pSeqList);
// 空间不够时动态增容
void _CheckCapacity(PSeqList pSeqList);
// 尾部插入
void PushBack(PSeqList pSeqList, DataType data);
// 尾部删除
void PopBack(PSeqList pSeqList);
// 头部插入
void PushFront(PSeqList pSeqList, DataType data);
// 头部删除
void PopFront(PSeqList pSeqList);
// 顺序表中查找数据data，返回该元素在顺序表中的位置
int Find(PSeqList pSeqList, DataType data);
// 在顺序表的ipos位置上插入元素data
void Insert(PSeqList pSeqList, size_t pos, DataType data);
// 删除顺序表pos位置上的元素
void Erase(PSeqList pSeqList, size_t pos);
// 移除顺序表中的元素data
void Remove(PSeqList pSeqList, DataType data);
// 移除顺序表中的所有值为data的元素
void RemoveAll(PSeqList pSeqList, DataType data);
// 选择排序
void SelectSort(PSeqList pSeqList);
// 冒泡排序
void BorbbleSort(PSeqList pSeqList);
// 查找已排序顺序表中的元素data
int BinarySearch(PSeqList pSeqList, DataType data);
// 改变顺序表中元素的个数，Size为元素的个数
void ReSize(PSeqList pSeqList, int Size);
// 打印顺序表
void PrintSeqList(PSeqList pSeqList);
// 销毁动态顺序表
void DestroyList(PSeqList pSeqList);

2、用于实现声明的.c文件

#include "SeqList_D.h"

void InitSeqList(PSeqList pSeqList)
{
    pSeqList->size = 0;
    pSeqList->capacity = 5;       
    pSeqList->pData = (DataType *)malloc(pSeqList->capacity * sizeof(DataType));
    //malloc()函数的参数是字节数的个数，而不是元素的个数，因此要加上 *sizeof(DataType)
    if (NULL == pSeqList->pData)
    {
        printf("初始化顺序表失败");
    }
}


int Check_Capacity(PSeqList pSeqList)
{
    DataType* temp = pSeqList->pData;
    assert(pSeqList);
    if (pSeqList->size >= pSeqList->capacity)     //满足条件说明顺序表已满，再想执行插入操作就得再开辟空间
    {
        DataType Newcapacity = pSeqList->capacity + 5;
        pSeqList->pData = (DataType *)realloc(pSeqList->pData, Newcapacity * sizeof(DataType));
        //这儿是用realloc()函数而非malloc()函数，因为这儿是给原有空间增容，而不是开辟新的空间
        if (NULL == pSeqList->pData)
        {
            pSeqList->pData = temp;     //temp指向的是扩容之前顺序表储存的空间，那么要是扩容失败，使此时的顺序表可以
            //还是指向扩容前的空间，那么就不会丢失数据
            printf("扩容失败");
            return -1;       //扩容失败，就返回负值，说明此时不能插入数据
        }
        else
        {
            pSeqList->capacity = Newcapacity;
            //当空间开辟失败时，不应该改变pSeqList->capacity的值，只有当空间开辟成功了，才能让pSeqList->capacity
            //等于新开辟的空间能容纳的元素个数
        }
    }
    return 1;
}

void PushBack(PSeqList pSeqList, DataType data)
{
    int ret = 0;
    size_t index = 0;        //因为下标是不可能为负数的，所以次数定义为无符号整型比较好
    assert(pSeqList);
    ret = Check_Capacity(pSeqList);   //根据函数返回值确定是否扩容成功（不需要扩容的情况也算作扩容成功）
    if (1 == ret)
    {
        pSeqList->pData[pSeqList->size] = data;   //指针指向的内容也可以用数组下标的形式来访问
        pSeqList->size++;
    }
}

void PopBack(PSeqList pSeqList)
{
    assert(pSeqList);
    if (pSeqList->size == 0)
    {
        printf("顺序表里没有数据元素!\n");
        //当pSeqList->size等于0，说明顺序表里没有数据，此时是无法移除的
        return;
    }
    pSeqList->size--;
}

void PushFront(PSeqList pSeqList, DataType data)
{
    int ret = 0;
    size_t index = pSeqList->size; 
    assert(pSeqList);
    ret = Check_Capacity(pSeqList);     //插入元素之前先检测顺序表是否还有空间足够用来插入元素
    if (1 == ret)
    {
        for (; index > 0; index--)
        {
            pSeqList->pData[index] = pSeqList->pData[index - 1];
        }
        pSeqList->pData[index] = data;   //指针指向的内容也可以用数组下标的形式来访问
        pSeqList->size++;
    }
}

void PopFront(PSeqList pSeqList)
{
    size_t index = 0;
    assert(pSeqList);
    if (pSeqList->size == 0)
    {
        printf("顺序表里没有数据元素!\n");
        //当pSeqList->size等于0，说明顺序表里没有数据，此时是无法移除的
        return;
    }
    for (; index < pSeqList->size - 1; index++)
    {
        pSeqList->pData[index] = pSeqList->pData[index + 1];
        //因为循环结束条件是index = pSeqList->size - 1，那么进入循环最多是index = pSeqList->size - 2，
        //那么即使index + 1也不会发生越界访问
    }
    pSeqList->size--;
}

int Find(PSeqList pSeqList, DataType data)
{
    size_t index = 0;
    assert(pSeqList);
    for (; index < pSeqList->size; index++)
    {
        if (pSeqList->pData[index] == data)
        {
            return index + 1;   //一个元素的位置时从1开始计算的，而下标值是从0开始的，所以元素的位置是对应的下标值加1
        }
    }
    return -1;
}

void Insert(PSeqList pSeqList, size_t pos, DataType data)
{
    int ret = 0;
    size_t index = pSeqList->size;
    assert(pSeqList);
    if (pos > pSeqList->size)
    {
        printf("插入位置不合法。");
        //要保证数据元素插入后所有元素都是连续的，否则不能叫作顺序表
        return;
    }
    ret = Check_Capacity(pSeqList);     //插入元素之前先检测顺序表是否还有空间足够用来插入元素
    if (1 == ret)
    {
        for (; index >= pos; index--)
        {
            pSeqList->pData[index] = pSeqList->pData[index - 1];
        }
        pSeqList->pData[index] = data;   //指针指向的内容也可以用数组下标的形式来访问
        pSeqList->size++;
    }
}

void Erase(PSeqList pSeqList, size_t pos)
{
    size_t index = pos - 1;
    assert(pSeqList);
    if (pSeqList->size == 0)
    {
        printf("顺序表里没有数据元素!\n");
        //当pSeqList->size等于0，说明顺序表里没有数据，此时是无法移除的
        return;
        //若果此处不这样做，下面的pSeqList->size-1会溢出
    }
    for (; index < pSeqList->size - 1; index++)
    {
        pSeqList->pData[index] = pSeqList->pData[index + 1];
    }
    pSeqList->size--;
    //当pos == pSeqList->size时，不会进入循环，但这样也不会出错，因为它后面没有元素了，那么就不需要经过循环把元素
    //前移，直接把元素个数减1即可
}

void Remove(PSeqList pSeqList, DataType data)
{
    size_t index = 0; 
    size_t temp = 0;
    assert(pSeqList);
    for (; index < pSeqList->size; index++)
    {
        if (pSeqList->pData[index] == data)
        {
            for (temp = index; temp < pSeqList->size - 1; temp++) 
                //此处也可以直接用index操作，但用temp可以把两个变量的作用区分开
            {
                pSeqList->pData[temp] = pSeqList->pData[temp + 1];
            }
            //当在顺序表中找到了该数时，就把该数之后的所有元素全部向前挪一个元素的位置，把原数据覆盖即可达到移除的目的
            pSeqList->size--;
            //当要删除的数在顺序表中最后一个位置时，index == pSeqList->size-1,因此不会进入循环，但因为该数后面就
            //没有数据了，所以此时的移除方法是直接把该顺序表的元素个数减1，使该元素成为无效元素即可达到删除的目的
            return 0;
        }
    }
}

void RemoveAll(PSeqList pSeqList, DataType data)
{
    size_t index = 0;
    size_t temp = 0;
    assert(pSeqList);
    for (; index < pSeqList->size; index++)
    {
        if (pSeqList->pData[index] == data)
        {
            for (temp = index; temp < pSeqList->size - 1; temp++)
                //此处也可以直接用index操作，但用temp可以把两个变量的作用区分开
            {
                pSeqList->pData[temp] = pSeqList->pData[temp + 1];
            }
            //当在顺序表中找到了该数时，就把该数之后的所有元素全部向前挪一个元素的位置，把原数据覆盖即可达到移除的目的
            pSeqList->size--;
            index--;
            //index--是因为删除一个元素之后，后面的元素都会前移，那么可能前移元素中的最前面的元素和我们要删除的元素
            //的值是一样的，而此时index++了，它的值是前移元素中的第二个元素的值，因此要给index--，使它的值为前移元素
            //中的第一个元素的值
            //因为这个函数是要删除顺序表中所有的值为data的元素，所以在这儿不能直接删除一个就返回了，而是知道遍历所有
            //元素，删除对应的元素，才会返回
        }
    }
}

void Swap(size_t *num1, size_t *num2)
{
    size_t temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}

void SelectSort(PSeqList pSeqList)
{
    size_t num = 0;
    size_t index = 0;
    size_t end = pSeqList->size;
    assert(pSeqList);
    for (; num < pSeqList->size / 2; num++)
    {
        size_t min = num;
        size_t max = num;
        for (index = num + 1; index < end; index++)
        {
            min = pSeqList->pData[min] < pSeqList->pData[index] ? min : index;
            max = pSeqList->pData[max] > pSeqList->pData[index] ? max : index;
            //每次比较两个元素，把比较完成后最小和最大的元素的下标保存起来，下一次比较时比较的两个对象分别是保存的下
            //标对应的元素和还没有进行比较的所有元素中最前面的那一个元素(当然，也可以是未进行比较的所有元素中的任意一个)
        }
        Swap(&pSeqList->pData[min], &pSeqList->pData[num]);
        Swap(&pSeqList->pData[max], &pSeqList->pData[--end]); //注意这儿的--end是为了使下一次循环里的比较范围缩小，
                                                              //同时也为了这儿取得是正确的下标值
        //把最小和最大的元素交换到对应的位置去
    }
}

void BorbbleSort(PSeqList pSeqList)     //排序为从小到大
{
    size_t index = 0;
    size_t num = 0;
    int flag = 1;
    assert(pSeqList);
    while (flag == 1)   //对冒泡排序的优化，当某一趟排序时发现没有发生交换的情况，说明此时已经排序成功，那么就可以
                        //不用再进入下一趟排序，直接跳出循环，执行下面的操作
    {
        for (; num < pSeqList->size - 1; num++)       //思考冒泡排序两个循环的次数个应该各是多少
        {
            for (index = 0; index < pSeqList->size - num - 1; index++)   //不减1可能会造成越界访问
            {
                if (pSeqList->pData[index]>pSeqList->pData[index + 1])
                {
                    Swap(&pSeqList->pData[index], &pSeqList->pData[index + 1]);
                    //每次比较相邻两个元素，若前面的元素大于后面的，则交换两个元素的位置
                    flag = 1;
                }
            }
        }
    }
}

int BinarySearch(PSeqList pSeqList, DataType data)   //二分法在顺序表中找一个数
{
    int left = 0;
    int right = pSeqList->size - 1;
    assert(pSeqList);
    if (pSeqList->size == 0)  
    {
        return -1;
        //因为此时顺序表里没有数据，而pSeqList->size是无符号整型，减1的话出来的值是一个非常大的值，所以为了
        //保证函数的正确性，在顺序表无数据时，直接返回
    }
    while (left <= right)     //注意right的取值对此处是用：left <= right还是left < right的影响
    {
        int mid = left + (right - left) / 2;    //没有写成mid = (left + right) / 2是因为害怕怕两数直接相加会溢出
        if (pSeqList->pData[mid] == data)
        {
            return mid;
        }
        else if (pSeqList->pData[mid] > data)
        {
            right = mid - 1;     //因为排序的函数是把顺序表的元素由小到大排列的
        }
        else
        {
            left = mid + 1;
        }
    }
    return -1;  //当没有找到要查找的数时，返回一个负值，以声明要查找的元素在顺序表中不存在，因为要是找到了，
    //返回一个数的位置，那么不会小于0
}

void ReSize(PSeqList pSeqList, int Size)
{
    DataType* temp = pSeqList->pData;
    assert(pSeqList);
    if (Size > pSeqList->size) 
    {
        printf("操作失败");
        return;
        //因为顺序表中的元素是连续存放的，这样改变可能会使之后的操作造成顺序表中的元素分散存储
    }
    DataType Newcapacity = Size - Size % 5 + 5;    //此时不能直接把值赋给pSeqList->capacity，因为要是重新分配空间失败
    //那么pSeqList->capacity就不应该改变，所以应在保证空间成功开辟之后再把该值赋给pSeqList->capacity

    pSeqList->pData = (DataType*)realloc(pSeqList->pData, Newcapacity * sizeof(DataType));
    //给顺序表重新分配空间，使此时的剩余的空间能存储的元素个数不超过5个，以达到节省空间的目的
    if (NULL == pSeqList->pData)
    {
        pSeqList->pData = temp;
        printf("重新开辟空间失败");
        return;
    }
    pSeqList->capacity = Newcapacity;
    pSeqList->size = Size;
}

void PrintSeqList(PSeqList pSeqList)
{
    size_t index = 0;
    assert(pSeqList);
    for (; index < pSeqList->size; index++)
    {
        printf("%d  ", pSeqList->pData[index]);
    }
    printf("\n");
}

void DestroyList(PSeqList pSeqList)
{
    assert(pSeqList);
    pSeqList->size = 0;
    pSeqList->capacity = 0;
    free(pSeqList->pData);
    //把给顺序表分配的空间回收
}

3、用于测试函数正确性的Test.c文件

#include "SeqList_D.h"

SeqList seqList;

//测试尾插与尾删函数
void TestFun1()
{
    InitSeqList(&seqList);
    PushBack(&seqList, 1);
    PushBack(&seqList, 2);
    PushBack(&seqList, 3);
    PushBack(&seqList, 4);
    PrintSeqList(&seqList);
    PopBack(&seqList);
    PopBack(&seqList);
    PrintSeqList(&seqList);
}

//测试头插与头删函数
void TestFun2()
{
    InitSeqList(&seqList);
    PushFront(&seqList, 1);
    PushFront(&seqList, 2);
    PushFront(&seqList, 3);
    PushFront(&seqList, 4);
    PrintSeqList(&seqList);
    PopFront(&seqList);
    PopFront(&seqList);
    PrintSeqList(&seqList);
}

//测试任意位置查找插入删除函数
void TestFun3()
{
    int ret = 0;
    InitSeqList(&seqList);
    PushFront(&seqList, 1);
    PushFront(&seqList, 2);
    PushFront(&seqList, 3);
    PushFront(&seqList, 4);
    ret = Find(&seqList, 4);
    Insert(&seqList, 3, 5);
    Erase(&seqList, 5);
    printf("%d\n", ret);
    PrintSeqList(&seqList);
}

//测试移除函数
void TestFun4()
{
    InitSeqList(&seqList);
    PushFront(&seqList, 1);
    PushFront(&seqList, 2);
    PushFront(&seqList, 2);
    PushFront(&seqList, 4);
    PushFront(&seqList, 1);
    PushFront(&seqList, 2);
    PushFront(&seqList, 2);
    PushFront(&seqList, 4);
    Remove(&seqList, 2);
    PrintSeqList(&seqList);
    RemoveAll(&seqList, 2);
    PrintSeqList(&seqList);
}

//测试排序与二分查找函数
void TestFun5()
{
    int ret = 0;
    InitSeqList(&seqList);
    PushFront(&seqList, 3);
    PushFront(&seqList, 9);
    PushFront(&seqList, 1);
    PushFront(&seqList, 4);
    PushFront(&seqList, 2);
    PushFront(&seqList, 8);
    PushFront(&seqList, 7);
    PushFront(&seqList, 0);
    //SelectSort(&seqList);
    BorbbleSort(&seqList);
    ret = BinarySearch(&seqList, 5);
    printf("%d\n", ret);
    PrintSeqList(&seqList);
}

//测试改变元素个数与销毁动态顺序表的函数
void TestFun6()
{
    InitSeqList(&seqList);
    PushFront(&seqList, 1);
    PushFront(&seqList, 2);
    PushFront(&seqList, 2);
    PushFront(&seqList, 4);
    PushFront(&seqList, 1);
    PushFront(&seqList, 2);
    PushFront(&seqList, 2);
    PushFront(&seqList, 4);
    ReSize(&seqList, 6);
    PrintSeqList(&seqList);
    //DestroyList(&DestroyList);
    //PrintSeqList(&seqList);
}

int main()
{
    //TestFun1();
    //TestFun2();
    //TestFun3();
    //TestFun4();
    TestFun5();
    //TestFun6();
    system("pause");
    return 0;
}