SeqListD 顺序表的动态实现

由于静态顺序表开辟后内存是固定的，而需要存入的数据比较大而且需要变动时，此时静态顺序表是有缺陷的，这时就需要动态开辟；动态顺序表是基于静态顺序表所实现的，它空间不够时可以自动增容。
下面是具体代码的实现：

SeqListD.h      //头文件

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <assert.h>
#include <string.h>
#include<stdlib.h>
#define MAX 2
#define DEFAULT_SZ 3
#define DEFAULT_INC 2   //默认增长

typedef int DataType; //int 类型重命名为DataType

typedef struct SeqList
{
    DataType *data;
    int sz;
    int capacity;    //容量
}SeqList, *pSeqList;

void InitSeqList(pSeqList ps);
void PushBack(pSeqList ps, DataType d);
void PopBack(pSeqList ps);
void Display(const pSeqList ps);
void PushFront(pSeqList ps, DataType d);
void PopFront(pSeqList ps);
int Find(pSeqList ps, DataType d);
void Insert(pSeqList ps, DataType d, int pos);
void Remove(pSeqList ps, DataType d);
void RemoveAll(pSeqList ps, DataType d);
void Reverse(pSeqList ps);
void Sort(pSeqList ps);
int BinarySearch(pSeqList ps, DataType d);
#endif //__SEQLIST_H__

SeqList.c   //相关函数的具体实现

#include "SeqListD.h"

void InitSeqList(pSeqList ps)
{
    assert(ps != NULL);
    ps->sz = 0;
    ps->capacity = DEFAULT_SZ;
    ps->data = malloc(ps->capacity*sizeof(DataType));
    //memset(ps->data, 0, sizeof(ps->data));
    if (ps->data == NULL)
    {
        perror("malloc");//报错
        exit(EXIT_FAILURE);
    }
    memset(ps->data, 0, DEFAULT_SZ*sizeof(DataType));//初始化
    ps->capacity = DEFAULT_SZ;
}
void CheckCapacity(pSeqList ps)
{
    assert(ps != NULL);
    if (ps->sz == ps->capacity)
    {
        DataType*ptr = realloc(ps->data, (ps->capacity + DEFAULT_INC)*sizeof(DataType));
        if (ptr == NULL)
        {
            perror("realloc");
            exit(EXIT_FAILURE);
        }
        else
        {
            ps->data = ptr;
        }
        //printf("增容成功\n");
        ps->capacity += DEFAULT_INC;
    }
}
void PushBack(pSeqList ps, DataType d)
{
    assert(ps != NULL);
    CheckCapacity(ps);
    assert(ps->data != NULL);
    ps->data[ps->sz] = d;
    ps->sz++;
}
void PopBack(pSeqList ps)
{
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    ps->sz--;
}
void Display(const pSeqList ps)   //打印
{
    int i = 0;
    assert(ps != NULL);
    for (i = 0; i<ps->sz; i++)
    {
        printf("%d ", ps->data[i]);
    }
    printf("\n");
}
void PushFront(pSeqList ps, DataType d)
{
    int i = 0;
    assert(ps != NULL);
    CheckCapacity(ps);
    for (i = ps->sz; i > 0; i--)
    {
        ps->data[i] = ps->data[i - 1];
    }
    ps->data[0] = d;
    ps->sz++;
}
void PopFront(pSeqList ps)
{
    int i = 0;
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    for (i = 0; i < ps->sz - 1; i++)
    {
        ps->data[i] = ps->data[i + 1];
    }
    ps->sz--;
}
int Find(pSeqList ps, DataType d)
{
    //while ((ps->data[ps->sz]) != d)
    int i = 0;
    assert(ps != NULL);
    for (i = 0; i < ps->sz; i++)
    {
        if ((ps->data[i]) == d)
        {
            return i;
        }
    }
    return -1;
}
void Insert(pSeqList ps, DataType d, int pos)//插入
{
    int i = 0;
    assert(ps != NULL);

    if (pos == -1)
    {
        return;
    }
    CheckCapacity(ps);//扩容
    assert(ps->data != NULL);
    for (i = ps->sz; i > pos; i--)
    {
        ps->data[i] = ps->data[i - 1];
    }
    ps->data[pos] = d;
    ps->sz++;
}
void Remove(pSeqList ps, DataType d)
{
    int i = 0;
    assert(ps != NULL);
    //int pos = Find(ps, d);
    int pos = Find((pSeqList)ps, d);
    printf("%\n", pos);
    if (ps->sz == 0)
    {
        return;
    }
    if (pos != -1)
    {
        for (i = pos; i < ps->sz - 1; i++)
        {
            ps->data[i] = ps->data[i + 1];
        }
    }
    ps->sz--;
}
void RemoveAll(pSeqList ps, DataType d)  //移除所有的d
{
    int i = 0;
    assert(ps != NULL);
    int pos = Find(ps, d);
    if (ps->sz == 0)
    {
        return;
    }
    for (i = 0; i<ps->sz; i++)
    {
        if (d == ps->data[i])
        {
            //ps->data[i] = ps->data[i + 1];
            //ps->sz--;   两种实现方式
            Remove((pSeqList)ps->data, d);
        }
    }
}
void Reverse(pSeqList ps)   //逆序
{
    int left = 0;
    int right = ps->sz - 1;
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    while (left < right)
    {
        DataType tmp = ps->data[left];
        ps->data[left] = ps->data[right];
        ps->data[right] = tmp;
        left++;
        right--;
    }
}
void Sort(pSeqList ps)  //排序  小—>—大
{
    int i = 0;
    int j = 0;
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    for (i = 0; i < ps->sz; i++)
    {
        for (j = 0; j < ps->sz - 1 - i; j++)
        {
            if (ps->data[j]>ps->data[j + 1])
            {
                int tmp = ps->data[j];
                ps->data[j] = ps->data[j + 1];
                ps->data[j + 1] = tmp;
            }
        }
    }
}
int BinarySearch(pSeqList ps, DataType d) //二分法查找
{
    int left = 0;
    int right = ps->sz - 1;
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    while (left <= right)
    {
        int mid = left + ((right - left) >> 1);
        if (d > ps->data[mid])
        {
            left = mid + 1;
        }
        else if (d < ps->data[mid])
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

test.c   //测试代码

#include "SeqListD.h"

void test1()
{
    SeqList my_list;
    InitSeqList(&my_list);
    PushBack(&my_list, 1);
    PushBack(&my_list, 2);
    PushBack(&my_list, 3);
    PushBack(&my_list, 4);
    Display(&my_list);

    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
}
void test2()
{
    int pos = 0;
    SeqList my_list;
    InitSeqList(&my_list);
    PushFront(&my_list, 1);
    PushFront(&my_list, 2);
    PushFront(&my_list, 3);
    PushFront(&my_list, 4);
    Display(&my_list);

    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
}
void test3()
{
    SeqList my_list;
    InitSeqList(&my_list);
    PushBack(&my_list, 1);
    PushBack(&my_list, 2);
    PushBack(&my_list, 3);
    PushBack(&my_list, 6);
    PushBack(&my_list, 3);
    PushBack(&my_list, 2);
    Display(&my_list);

    Remove(&my_list, 3);    //删除3
    Display(&my_list);      //
    RemoveAll(&my_list, 2); //删除所有2
    Display(&my_list);
}
void test4()
{
    int pos = 0;
    SeqList my_list;
    InitSeqList(&my_list);
    PushBack(&my_list, 1);
    PushBack(&my_list, 2);
    PushBack(&my_list, 3);
    PushBack(&my_list, 4);
    Display(&my_list);

    pos = Find(&my_list, 3);  //查找
    printf("%d\n", pos);
    Insert(&my_list, 5, pos); //插入
    Display(&my_list);
}
void test5()
{
    int pos = 0;
    SeqList my_list;
    InitSeqList(&my_list);
    PushFront(&my_list, 1);
    PushFront(&my_list, 2);
    PushFront(&my_list, 3);
    PushFront(&my_list, 4);
    PushFront(&my_list, 1);
    Display(&my_list);

    Reverse(&my_list);  //逆序
    Display(&my_list);
    Sort(&my_list);     //排序
    Display(&my_list);
    pos = BinarySearch(&my_list, 3);//二分查找
    printf("%d\n", pos);
}
int main()
{
    test5();
    getchar();
    return 0;
}

运行结果 test1 :

test2 :

test3 :

test4 :

test5 :