动态顺序表

在实现动态顺序表的开头我们需要了解的知识（动态内存的管理）：

一、 malloc和free
二、calloc
三、 realloc

---

分别解析：
一、malloc和free

---

malloc和free都声明在stdlib.h中。
1、malloc动态内存开辟函数原型:void* malloc (size_t size);（申请比较大的空间时候使用）
（1）这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。
（2）如果开辟成功，则返回⼀个指向开辟好空间的指针。
（3）如果开辟失败，则返回⼀个NULL指针，因此malloc的返回值⼀定要做检查。
（4）返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定。
（5）如果参数size为0，malloc的⾏为是标准是未定义的，取决于编译器
（6）malloc申请的空间比实际的大些。
举例如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
    int size = 0;
    scanf("%d", &size);
    int *ptr = NULL;//定义一个ptr指针将其初始化为NULL
    ptr = (int *)malloc(size*sizeof(int));//申请了size个整型的空间
    if (NULL != ptr)//判断是否为空
    {
        int i = 0;
        for (i = 0; i < size; i++)//对空间进行初始化
        {
            *(ptr + i) = i;
        }
    }
    free(ptr);//释放ptr指向的动态内存。只能free一次.
    ptr = NULL;
    return 0;
}

1、
2、

---

2、free函数专门用来做动态内存的释放和回收的。
函数原型为：void free (void* ptr);
1、如果参数ptr指向的空间不是动态开辟的，那free函数的⾏为是未定义的。
2、如果参数 ptr 是NULL指针，则函数什么事都不做

---

二、calloc
calloc 函数也⽤来动态内存分配。（需要初始化时使用）
原型如下：
void* calloc (size_t num, size_t size);
函数的功能是：
（1）为num个⼤⼩为size的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
calloc与函数 malloc 的区别：
calloc会在返回地址之前把申请的空间的每个字节初始化为全0。
举例如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
    int a = 10;
    int *ptr = calloc(a, sizeof(int));
    if (NULL != ptr)
    {

    }
    free(ptr);
    ptr = NULL;
    return 0;
}

---

三、realloc
功能：
realloc函数可以做到对动态开辟内存⼤⼩的调整
函数原型：
void* realloc (void* ptr, size_t size);
解析：
（1）ptr 是要调整的内存地址
（2）size 调整之后新⼤⼩
（3）返回值为调整之后的内存起始位置。
（4）这个函数调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到 新 的空间。
（5）realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有⾜够⼤的空间，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。

情况2：原有空间之后没有⾜够⼤的空间，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。

举例如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{

    int *ptr = malloc(sizeof(int)*100);
    if (NULL != ptr)
    {
        //进行处理
    }
    else
    {
        exit(EXIT_FAILURE);
    }
    int *q = NULL;
    q = realloc(ptr,1000);
    if (NULL != ptr)
    {
        ptr = q;
    }
    free(ptr);
    ptr = NULL;
    return 0;
}

---

SeqlistD.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<malloc.h>
typedef int DataType;
typedef struct SeqlistD
{
    DataType * array;//存储空间的基地址
    size_t  size;//有效数据的个数
    size_t capacity;当前分配的存储容量（以sizeof（DataType）为单位）
}SeqlistD;
void InitSeqlistD(SeqlistD *s);//初始化动态顺序表
void PushFront(SeqlistD *s, DataType x);//头插
void PopFront(SeqlistD *s);//头删
void PushBack(SeqlistD *s, DataType x);//尾插
void PopBack(SeqlistD *s);//尾删
void PrintSeqlistD(SeqlistD *s);//打印动态顺序表
void CheckCapacity(SeqlistD *s);//判断容量是否已经满了
void DestorySeqlist(SeqlistD *s);//销毁顺序表
void SeqlistDClear(SeqlistD *s);//清空数据表
void Insert(SeqlistD *s, int pos, DataType x);//在指定位置插入一个元素
int SeqListDSize(SeqlistD *s);// 获取元素个数

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"SeqlistD.h"
void InitSeqlistD(SeqlistD *s)//初始化动态顺序表
{
    assert(s);
    s->array = (DataType*)malloc(3 * sizeof(DataType));
    assert(s->array);
    s->size = 0;
    s->capacity = 3;
}

void PushFront(SeqlistD *s, DataType x)//头插
{
    int i = s->size;
    assert(s);
    for (; i >= 0; i--)
    {
        s->array[i] = s->array[i - 1];
    }
    s->array[0] = x;
    s->size++;
}

void PopFront(SeqlistD *s)//头删
{
    int i = 0;
    if (s->size == 1)
    {
        s->size = 0;
    }
    else
    {
        for (i = 0; i < s->size; i++)
        {
            s->array[i] = s->array[i + 1];
        }
    }
    s->size--;
}

void PushBack(SeqlistD *s, DataType x)//尾插
{
    assert(s);
    CheckCapacity(s);
    s->array[s->size++] = x;
}

void PopBack(SeqlistD *s)//尾删
{
    s->size--;
    printf("删除成功 ");
}

void PrintSeqlistD(SeqlistD *s)//打印动态顺序表
{
    size_t i = 0;
    for (; i< s->size; ++i)
    {
        printf("%d ", s->array[i]);
    }
    printf("\n");
}
void CheckCapacity(SeqlistD *s)
{
    if (s->size == s->capacity)
    {
        s->array = (DataType*)realloc(s->array, 2 * s->capacity*sizeof(DataType));
        assert(s->array);
        s->capacity *= 2;

    }
}

void DestorySeqlist(SeqlistD *s)//销毁顺序表
{
    free(s->array);
    s->array = NULL;
    s->capacity = s->size = 0;

}

void SeqlistDClear(SeqlistD *s)//清空数据表
{
    s->size = 0;
}

void Insert(SeqlistD *s, int pos, DataType x)//在指定位置插入一个元素
{
    int i = s->size;
    assert(s);
    if (pos > i + 1)//此处判断该位置是否是合理的位置
    {
        printf("您输入的位置有错误,无法识别\n ");
        return;
    }

    for (i = s->size; i >= pos; i--)
    {
        s->array[i] = s->array[i - 1];//从pos位置向后的所有元素
    }

    s->array[pos - 1] = x;
    s->size++;
}

int SeqListDSize(SeqlistD *s)// 获取元素个数
{
    return s->size;
}


int main()
{
    void TestSeqlistD();
    {
        SeqlistD s;
        InitSeqlistD(&s);
        PushBack(&s, 1);
        PushBack(&s, 2);
        PushBack(&s, 3);
        PushBack(&s, 4);

        //Insert(&s, 2, 3);
        //SeqlistDClear(&s);
        PrintSeqlistD(&s);
        PushBack(&s, 5);
        PrintSeqlistD(&s);
        printf("%d\n",SeqListDSize(&s));


        //DestorySeqlist(&s);
    }


    return 0;
}