动态顺序表-c语言实现

   上一篇实现了顺序表的静态实现，那么有没有一种更为优化的实现方式呢？
   当然有，仿照之前实现的通讯录，接下来我们来实现一下动态的顺序表~

SeqListD.h

#ifndef __SEQLISTD_H__
#define __SEQLISTD_H__

#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

#define DEFAULT_SZ 2
#define DEFAULT_INC 1


typedef int DataType;

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

void InitSeqList(pSeqList ps);//初始化
void DestroySeqList(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 //__SEQLISTD_H__

SeqListD.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"CeqListD.h"

void InitSeqList(pSeqList ps)
{
    ps->sz = 0;
    ps->data = malloc(DEFAULT_SZ*sizeof(DataType));
    if (ps->data == NULL)
    {
        perror("use malloc");
        exit(EXIT_FAILURE);
    }
    memset(ps->data, 0, DEFAULT_SZ*sizeof(DataType));
    ps->sz = 0;
    ps->capacity = DEFAULT_SZ;
}
void CheckCapacity(pSeqList ps)
{
    if (ps->sz == ps->capacity)
    {
        DataType* p = realloc(ps->data, (ps->capacity + DEFAULT_INC)*sizeof(DataType));
        if (p == NULL)
        {
            perror("realloc");
            exit(EXIT_FAILURE);
        }
        else
        {
            ps->data = p;
        }
        ps->capacity += DEFAULT_INC;

    }
}
void Display(const pSeqList ps)
{
    assert(ps != NULL);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        printf("%d ", ps->data[i]);
    }
    printf("\n");
}
void PushBack(pSeqList ps, DataType d)
{
    assert(ps != NULL);
    CheckCapacity(ps);
    ps->data[ps->sz] = d;
    ps->sz++;
}
void PopBack(pSeqList ps, DataType d)
{
    assert(ps->sz != NULL);
    if (ps->sz == 0)
    {
        return 0;
    }
    ps->sz--;
}
void PushFront(pSeqList ps, DataType d)
{
    assert(ps != NULL);
    CheckCapacity(ps);
    int i = 0;
    memmove(ps->data + 1, ps->data, sizeof(DataType)*(ps->sz));

    /*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)
{
    int i = 0;
    assert(ps != NULL);
    for (i = 0; i < ps->sz; i++)
    {
        if (d == ps->data[i])
        {
            return i;
        }
    }
    return -1;
}


void Insert(pSeqList ps, DataType d, int pos)
{
    int i = 0;
    assert(ps != NULL);
    CheckCapacity(ps);
    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 pos = 0;
    assert(ps != NULL);
    pos = Find(ps, d);
    if (pos != -1)
    {
        memmove(ps->data + pos, ps->data + pos + 1, sizeof(DataType)*(ps->sz - pos - 1));
        ps->sz--;
    }
}
void RemoveAll(pSeqList ps, DataType d)
{
    int i = 0;
    assert(ps != NULL);
    for (i = 0; i < ps->sz; i++)
    {
        if (d == ps->data[i])
        {
            memmove(ps->data + i, ps->data + i + 1, sizeof(DataType)*(ps->sz - i - 1));
            ps->sz--;
        }
    }
}


void Reverse(pSeqList ps)
{
    DataType *left = ps->data;
    DataType *right = ps->data + ps->sz - 1;
    assert(ps != NULL);
    while (left < right)
    {
        DataType temp = *left;
        *left = *right;
        *right = temp;
        left++;
        right--;
    }
}
void Sort(pSeqList ps)
{
    int i = 0;
    int j = 0;
    assert(ps != NULL);
    for (i = 0; i < ps->sz - 1; i++)
    {
        for (j = 0; j < ps->sz - 1; j++)
        {
            if (ps->data[j]>ps->data[j + 1])
            {
                DataType temp = 0;
                temp = ps->data[j];
                ps->data[j] = ps->data[j + 1];
                ps->data[j + 1] = temp;
            }
        }
    }
}
int BinarySearch(pSeqList ps, DataType d)
{
    int i = 0;
    int left = 0;
    int right = ps->sz - 1;
    assert(ps != NULL);
    while (left < right)
    {
        int  mid = left + (right - left) / 2;
        if (ps->data[mid]>d)
        {
            right = mid - 1;
        }
        else if (ps->data[mid]<d)
        {
            left = mid + 1;
        }
        else
        {
            return mid;
        }
        /*for (i = 0; i < ps->sz - 1; i++)
        {
        if (ps->data[i] == d)
        {
        return i;
        }
        }*/
    }
    return -1;
}
void DestroySeqList(pSeqList ps)
{
    free(ps->data);
    ps->data = NULL;
    ps->capacity = 0;
    ps->sz = 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"CeqListD.h"
test1()
{
    SeqList my_list;
    InitSeqList(&my_list);
    PushBack(&my_list, 1);
    PushBack(&my_list, 2);
    PushBack(&my_list, 3);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    DestroySeqList(&my_list);
}
test2()
{
    SeqList my_list;
    InitSeqList(&my_list);
    PushFront(&my_list, 1);
    PushFront(&my_list, 2);
    PushFront(&my_list, 3);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    DestroySeqList(&my_list);
}

test3()
{
    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);
    pos = Find(&my_list, 3);
    if (pos == -1)
    {
        printf("要查找的元素不存在\n");
    }
    else
    {
        Insert(&my_list, 7, pos);
    }
    Display(&my_list);
    DestroySeqList(&my_list);
}

test4()
{
    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);
    Remove(&my_list, 1);
    Display(&my_list);
    Remove(&my_list, 4);
    Display(&my_list);
    DestroySeqList(&my_list);
}
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, 1);
    PushFront(&my_list, 4);
    PushFront(&my_list, 1);
    Display(&my_list);
    RemoveAll(&my_list, 1);
    Display(&my_list);
    DestroySeqList(&my_list);
}
test6()
{
    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);
    Reverse(&my_list);
    Display(&my_list);
    DestroySeqList(&my_list);
}
test7()
{
    SeqList my_list;
    InitSeqList(&my_list);
    PushFront(&my_list, 1);
    PushFront(&my_list, 2);
    PushFront(&my_list, 3);
    PushFront(&my_list, 6);
    PushFront(&my_list, 0);
    PushFront(&my_list, 4);
    Display(&my_list);
    Sort(&my_list);
    Display(&my_list);
    DestroySeqList(&my_list);
}
test8()
{
    int ret = 0;
    SeqList my_list;
    InitSeqList(&my_list);
    PushBack(&my_list, 1);
    PushBack(&my_list, 2);
    PushBack(&my_list, 3);
    PushBack(&my_list, 4);
    PushBack(&my_list, 5);
    PushBack(&my_list, 6);
    Display(&my_list);
    ret = BinarySearch(&my_list, 3);
    printf("%d\n", ret);
    DestroySeqList(&my_list);
}

int main()
{
    //test1();
    //test2();
    //test3();
    //test4();
    //test5();
    //test6();
    //test7();
    test8();
    getchar();
    return 0;
}