线性表（顺序存储结构——动态数组）

动态数组就是顺序存储结构，逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。

总结：顺序表（线性表的顺序存储结构）的特点

1. 利用数据元素的存储位置表示线性表相邻数据元素之间的前后关系，即线性表的逻辑结构和存储结构一致
2. 在访问线性表时，可以快速的计算出任何一个元素的存储地址。
3. 这种存取元素的方法被称为随机存储法

顺序表的优缺点：
优点：

1. 存储密度大
2. 可以随机存取表中任意一个元素

缺点：

1. 在插入、删除某一元素时，需要移动大量元素
2. 浪费存储空间
3. 属于静态随机存储形式，数据元素个个数不能自由扩充

DynamicArray.h 头文件

#ifndef DYNAMIC_ARRAY_H
#define DYNAMIC_ARRAY_H

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


//动态增长内存，策略 将存放数据的内存放在堆上
//容量capacity表示这块内存空间可以存放多少元素
//size概念 记录当前数组中具体的元素个数

//动态数组的结构体定义
typedef struct DYNAMICARRAY {
    int* pAddr;     //存放数据的地址
    int size;       //当前有多少个元素
    int capacity;   //容器，容器当前最大能容纳多少元素
}Dynamic_Array;

//写一系列的相关对DYNAMICARRAY结构体操作的函数
//初始化
Dynamic_Array* Array_Init();
//插入
void PushBack_Array(Dynamic_Array* arr, int value);
//删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos);
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value);
//查找
int Find_Array(Dynamic_Array* arr, int value);
//打印
void Print_Array(Dynamic_Array* arr);
//释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr);
//清空数组
void Clear_Array(Dynamic_Array* arr);
//获得动态数组容量
int Capacity_Array(Dynamic_Array* arr);
//获得动态数据当前的元素个数
int Size_Array(Dynamic_Array* arr);
//根据位置获得某个位置元素
int At_Array(Dynamic_Array* arr,int pos);

#endif

DynamicArray.c 动态数组的各种操作详解

#include "DynamicArray.h"

//动态数组初始化
Dynamic_Array* Array_Init()
{
    //申请动态内存
    Dynamic_Array* myArray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));
    //初始化
    myArray->size = 0;
    myArray->capacity = 20;
    myArray->pAddr =(int*)malloc(sizeof(int) * myArray->capacity);

    return myArray;
}
//插入
void PushBack_Array(Dynamic_Array* arr, int value)
{
    if (arr == NULL)
    {
        return;
    }

    //判断空间是否足够
    if (arr->size == arr->capacity)
    {
         //第一步 申请一块更大的空间 新空间是旧空间的2倍
        int* newSpace = (int*)malloc(sizeof(int) * arr->capacity * 2);
        //第二步 拷贝数据到新的空间
        memcpy(newSpace, arr->pAddr, arr->capacity * sizeof(int));
        //第3步 释放旧空间的内存
        free(arr->pAddr);

        //更新容量
        arr->capacity = arr->capacity * 2;
        arr->pAddr = newSpace;
    }
    //插入新元素
    arr->pAddr[arr->size] = value;
    arr->size++;

}
//删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos)
{
    if (arr == NULL)
    {
        return;
    }

    //判断位置是否有效
    if (pos < 0 || pos >= arr->size)
    {
        return;
    }

    //删除元素
    for (int i = pos; i < arr->size-1; i++)
    {
        arr->pAddr[i] = arr->pAddr[i + 1];
    }
    arr->size--;
}
//根据值删除value第一次出现的位置
void RemoveByValue_Array(Dynamic_Array* arr, int value)
{
    if (arr == NULL)
    {
        return;
    }

    //找到值的位置
    int pos = Find_Array(arr,value);
   
    //根据位置删除
    RemoveByPos_Array(arr, pos);
}
//查找
int Find_Array(Dynamic_Array* arr, int value)
{
    if (arr == NULL)
    {
        return -1;
    }

    //查找
    //找到值的位置
    int pos = -1;
    for (int i = 0; i < arr->size; i++)
    {
        if (arr->pAddr[i] == value)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//打印
void Print_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
    {
        return;
    }
    for (int i = 0; i < arr->size; i++)
    {
        printf("%d ", arr->pAddr[i]);
    }
    printf("\n");
}
//释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr)
{
    if (arr == NULL) 
    {
        return;
    }
    if (arr->pAddr != NULL)
    {
        free(arr->pAddr);
    }
    free(arr);
}
//清空数组
void Clear_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
    {
        return;
    }
    //pAddr -> 空间
    arr->size = 0;
}
//获得动态数组容量
int Capacity_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
    {
        return -1;
    }
    return arr->capacity;
}
//获得动态数据当前的元素个数
int Size_Array(Dynamic_Array* arr)
{
    if (arr == NULL)
    {
        return -1;
    }
    return arr->size;
}
//根据位置获得某个位置元素
int At_Array(Dynamic_Array* arr, int pos)
{
    if (arr == NULL)
    {
        return -1;
    }
    return arr->pAddr[pos];
}

动态数组.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "DynamicArray.h"

void test01()
{
    //初始化动态数组
	Dynamic_Array* myArray = Array_Init();
	//打印容量
	printf("数组容量：%d\n", Capacity_Array(myArray));
	printf("数组大小：%d\n", Size_Array(myArray));
	//插入元素
	for (int i = 0; i < 30; i++)
	{
		PushBack_Array(myArray, i);
	}
	printf("数组容量：%d\n", Capacity_Array(myArray));
	printf("数组大小：%d\n", Size_Array(myArray));
	//打印
	Print_Array(myArray);
	//删除
	RemoveByPos_Array(myArray, 0);
	RemoveByPos_Array(myArray, 27);
	//打印
	Print_Array(myArray);

	//查找第5个位置
	int pos = Find_Array(myArray, 5);
	printf("5查找到位置：%d %d\n", pos, At_Array(myArray, pos));

	//销毁
	FreeSpace_Array(myArray);
}

int main(void)
{
	test01();

	system("pause");
	return 0;
}