数据结构之顺序表（动态数组）

其他 2018-09-03 22:11:17 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/boy_of_god/article/details/81939396

线性表

  • 线性表的顺序存储(顺序表)
  • 线性表的链式存储（链表）
    线性表的定义：
  • 1、线性表(List)是零个或多个数据元素的集合
  • 2、线性表中的数据元素之间是有顺序的
  • 3 、线性表中的数据元素的类型必须相同
  • 4、线性表中的数据元素个数是有限的

1、顺序表（动态数组）

1.1、定义：

这里写图片描述

1.2、算法

  • 1、效果数组变量pBase指向一些后，数组里面不再是垃圾值
    void InitArray(struct Array* pArr,int capacity);

  • 2、判断是否为满
    bool IsFull(struct Array* pArr);

  • 3、追加不满时追加
    void AppendArray(struct Array* pArr,int val);

  • 4、判断数组是否为空
    bool IsEmpty(struct Array* pArr);

  • 5、输出数组的中的数据
    void ShowArray(struct Array* pArr);

  • 6、计算数组的容量
    int CapacityArray(struct Array* pArr);

  • 7、计算素组的长度有效元素的个数
    int LengthArray(struct Array* pArr);

  • 8、插入 pos的值是从1开始即下标为0时是第一个元素
    bool InsertArray(struct Array* pArr,int pos,int val);

  • 9、删除通过元素的位置
    bool DeleteByPosArray(struct Array* pArr,int pos,int *val);

  • 10、查找返回元素的下标
    int FindPosArray(struct Array* pArr,int val);

  • 11、删除通过值
    bool DeleteByvalueArray(struct Array* pArr,int val);

  • 12、翻转
    void InversionArray(struct Array* pArr);

  • 13、升序
    void SortArray(struct Array* pArr);

  • 14、清空数组
    void ClearArray(struct Array* pArr);

  • 15、释放
    void DestoryArray(struct Array* pArr);

1.3实现

1.3.0定义数据类型

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return 0;
}


int main()
{
    test();
    return 0;
}

1.3.1初始化

1.3.1.0思想
  • 1、申请一块内存空间
  • 2、使pArr->pBase指向那块内存空间
  • 3、数组的长度置为零，容量由用户决定
1.3.1.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return 0;
}


int main()
{
    test();
    return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}

1.3.2判断是否满

1.3.2.0思想
  • 数组有效元素的个数是否等于数组的容量
    pArr->capacity == pArr->len
1.3.2.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return ;
}


int main()
{
    test();
    return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
        return true;
    else
        return false;
}

1.3.3追加

1.3.3.0思想
1.3.3.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return ;
}


int main()
{
    test();
    return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
        return true;
    else
        return false;
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}

1.3.4判断是否为空

1.3.4.0思想
  • 判断数组的长度是否等于零
    0 == pArr->len
1.3.4.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    return ;
}


int main()
{
    test();
    return 0;
}
//数组的初始化
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
        return true;
    else
        return false;
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{
    if(0 == pArr->len)
        return true;
    else
        return false;
}

1.3.5输出数组

1.3.5.0思想
  • 1、判断数组是否为空，空则返回
  • 2、遍历数组知道循环变量小于数组的有效元素的个数(len-1为数组最后一个值的下标)
    i = 0;i < pArr->len; i++
1.3.5.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i ;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}

运行结果：
这里写图片描述

1.3.6求数组的容量

1.3.6.0思想
  • 返回数组的容量
    return pArr->capacity;
1.3.6.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}

运行结果：
这里写图片描述

1.3.7求数组的长度

1.3.7.0思想
  • 返回数组的长度
    return pArr->len;
1.3.7.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}

int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}

运行结果;
这里写图片描述

1.3.8、插入按指定位置插入数据

1.3.8.0、思想
  • 1、判断线性表是否合法
  • 2、判断数组是否已满
  • 3、判断插入位置是否合法
  • 4、把最后一个元素到插入位置的元素后移一个位置
  • 5、将新元素插入
  • 6、线性表长度加1
1.3.8.1、分析图：

图一：
这里写图片描述
图二：
这里写图片描述

方法一：

for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
    pArr->pBase[i+1] = pArr->pBase[i];
pArr->pBase[pos-1] =val;

      方法二：

for(i = pArr->len;i>=pos;i--)
    pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
par->Base[pos-1];
1.3.8.2、代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}

运行结果：
这里写图片描述

1.3.9删除通过元素位置删除一元素

1.3.9.0思想
  • 1、判断线性表是否合法
  • 2、判断线性表是否为空
  • 3、判断删除位置是否合法
  • 4、将元素取出
  • 5、将删除位置后的元素分别向前移动一个位置
  • 6、线性表长度减1
1.3.9.1、分析图

这里写图片描述

1.3.9.2、代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性判断数组是否合法
    if(IsEmpty(pArr))//判断数组是否为空
        return false;
    if(pos<1 || pos > pArr->len)//判断删除的为值是否合法
        return false;
    *val = pArr->pBase[pos-1];//把要删除的元素值通过指针传给主函数
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}

运行结果:
这里写图片描述

1.3.10查找返回元素的下标

1.3.10.0思想
1.3.10.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
int FindPosArray(struct Array* pArr,int val);//查找返回元素的下标
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val,vpos;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    printf("======查找元素的下标=====\n\n");
    vpos = FindPosArray(&arr,10);
    printf("元素10的下标为:%d\n",vpos);

    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性
    if(IsEmpty(pArr))
        return false;
    if(pos<1 || pos > pArr->len)
        return false;
    *val = pArr->pBase[pos-1];
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//查找元素的下标
int FindPosArray(struct Array* pArr,int val)//查找返回元素的下标若为-1时不存在
{
    int pos = -1;
    int i;
    if(NULL == pArr)
        return -1;//健壮性
    for(i = 0;i<pArr->len;i++)
    {
        if(pArr->pBase[i] == val)
        {
            pos = i;
            break;
        }
    }
    return pos;
}

运行结果：
这里写图片描述

1.3.11删除通过元素的值删除一个元素

1.3.11.0思想
  • 1、先找到元素的下标
  • 2、下标加一等于元素的位置
  • 3、通过元素的位置删除
1.3.11.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
int FindPosArray(struct Array* pArr,int val);//查找返回元素的下标
bool DeleteByValueArray(struct Array* pArr,int val);//删除通过值
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val,vpos;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    printf("======查找元素的下标=====\n\n");
    vpos = FindPosArray(&arr,10);
    printf("元素10的下标为:%d\n",vpos);
    printf("======通过元素的值删除元素======\n\n");
    if(DeleteByValueArray(&arr,6))
        printf("删除值为6的元素成功\n");
    else
        printf("删除失败！\n");
    ShowArray(&arr);

    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性
    if(IsEmpty(pArr))
        return false;
    if(pos<1 || pos > pArr->len)
        return false;
    *val = pArr->pBase[pos-1];
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//查找元素的下标
int FindPosArray(struct Array* pArr,int val)//查找返回元素的下标若为-1时不存在
{
    int pos = -1;
    int i;
    if(NULL == pArr)
        return -1;//健壮性
    for(i = 0;i<pArr->len;i++)
    {
        if(pArr->pBase[i] == val)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//通过元素值删除元素
bool DeleteByValueArray(struct Array* pArr,int val)//删除通过值
{
    int i,pos;
    if(NULL == pArr)
        return false;
    pos = FindPosArray(pArr,val);
    pos = pos+1;//将下标转化成位置
    if(pos<1 || pos > pArr->len)
        return false;
    for(i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}

运行结果:
这里写图片描述

1.3.12反转

1.3.12.0思想
  • 1、判断数组是否合法
  • 2、判断数组是否为空
  • 3、循环反转
1.2.12.1分析图：

这里写图片描述

1.3.12.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
int FindPosArray(struct Array* pArr,int val);//查找返回元素的下标
bool DeleteByValueArray(struct Array* pArr,int val);//删除通过值
void InversionArray(struct Array* pArr);//翻转
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val,vpos;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    printf("======查找元素的下标=====\n\n");
    vpos = FindPosArray(&arr,10);
    printf("元素10的下标为:%d\n",vpos);
    printf("======通过元素的值删除元素======\n\n");
    if(DeleteByValueArray(&arr,6))
        printf("删除值为6的元素成功\n");
    else
        printf("删除失败！\n");
    ShowArray(&arr);
    printf("======翻转======\n");
    InversionArray(&arr);
    ShowArray(&arr);

    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性
    if(IsEmpty(pArr))
        return false;
    if(pos<1 || pos > pArr->len)
        return false;
    *val = pArr->pBase[pos-1];
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//查找元素的下标
int FindPosArray(struct Array* pArr,int val)//查找返回元素的下标若为-1时不存在
{
    int pos = -1;
    int i;
    if(NULL == pArr)
        return -1;//健壮性
    for(i = 0;i<pArr->len;i++)
    {
        if(pArr->pBase[i] == val)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//通过元素值删除元素
bool DeleteByValueArray(struct Array* pArr,int val)//删除通过值
{
    int i,pos;
    if(NULL == pArr)
        return false;
    pos = FindPosArray(pArr,val);
    pos = pos+1;//将下标转化成位置
    if(pos<1 || pos > pArr->len)
        return false;
    for(i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//翻转
void InversionArray(struct Array* pArr)
{

    int i = 0;
    int j = pArr->len-1;//数组最后一个元素的下标
    int t;//定义临时变量用于交换的的中间值
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
        return;
    while(i<j)
    {
        if(pArr->pBase[i] == pArr->pBase[j])//如果两个数相同不用交换
            break;
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }
}

运行结果：
这里写图片描述

1.3.13排序

1.3.13.0思想
  • 冒泡【控制好边界的判断】
1.3.13.1、分析图：

这里写图片描述

1.3.13.2代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
int FindPosArray(struct Array* pArr,int val);//查找返回元素的下标
bool DeleteByValueArray(struct Array* pArr,int val);//删除通过值
void InversionArray(struct Array* pArr);//翻转
void SortArray(struct Array* pArr);//升序
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val,vpos;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    printf("======查找元素的下标=====\n\n");
    vpos = FindPosArray(&arr,10);
    printf("元素10的下标为:%d\n",vpos);
    printf("======通过元素的值删除元素======\n\n");
    if(DeleteByValueArray(&arr,6))
        printf("删除值为6的元素成功\n");
    else
        printf("删除失败！\n");
    ShowArray(&arr);
    printf("======翻转======\n");
    InversionArray(&arr);
    ShowArray(&arr);
    printf("======升序排序======\n");
    SortArray(&arr);
    ShowArray(&arr);

    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return -1;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性
    if(IsEmpty(pArr))
        return false;
    if(pos<1 || pos > pArr->len)
        return false;
    *val = pArr->pBase[pos-1];
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//查找元素的下标
int FindPosArray(struct Array* pArr,int val)//查找返回元素的下标若为-1时不存在
{
    int pos = -1;
    int i;
    if(NULL == pArr)
        return -1;//健壮性
    for(i = 0;i<pArr->len;i++)
    {
        if(pArr->pBase[i] == val)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//通过元素值删除元素
bool DeleteByValueArray(struct Array* pArr,int val)//删除通过值
{
    int i,pos;
    if(NULL == pArr)
        return false;
    pos = FindPosArray(pArr,val);
    pos = pos+1;//将下标转化成位置
    if(pos<1 || pos > pArr->len)
        return false;
    for(i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//翻转
void InversionArray(struct Array* pArr)
{

    int i = 0;
    int j = pArr->len-1;//数组最后一个元素的下标
    int t;//定义临时变量用于交换的的中间值
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
        return;
    while(i<j)
    {
        if(pArr->pBase[i] == pArr->pBase[j])//如果两个数相同不用交换
            break;
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }
}
//排序
void SortArray(struct Array* pArr)//升序
{
    int i,j;
    int t;//用于交换的临时变量
    for(i = 0;i<pArr->len-1;i++)//最大下标等于有效元素个数-1
    {
        for(j = i+1;j<=pArr->len-1;j++)
        {
            if(pArr->pBase[i] > pArr->pBase[j])
            {
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }
}

运行结果；
这里写图片描述

1.3.14获取元素通过下标

1.3.14.1思想
  • 1、判断下标是否越界
  • 2、取值
    return pArr->pBase[index];
1.3.14.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
int FindPosArray(struct Array* pArr,int val);//查找返回元素的下标
bool DeleteByValueArray(struct Array* pArr,int val);//删除通过值
void InversionArray(struct Array* pArr);//翻转
void SortArray(struct Array* pArr);//升序
int AtArray(struct Array* pArr,int index);//通过下标获取元素的值
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val,vpos;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    printf("======查找元素的下标=====\n\n");
    vpos = FindPosArray(&arr,10);
    printf("元素10的下标为:%d\n",vpos);
    printf("======通过元素的值删除元素======\n\n");
    if(DeleteByValueArray(&arr,6))
        printf("删除值为6的元素成功\n");
    else
        printf("删除失败！\n");
    ShowArray(&arr);
    printf("======翻转======\n");
    InversionArray(&arr);
    ShowArray(&arr);
    printf("======升序排序======\n");
    SortArray(&arr);
    ShowArray(&arr);
    printf("下标为2的元素的值为：%d\n",AtArray(&arr,2));

    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return false;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性
    if(IsEmpty(pArr))
        return false;
    if(pos<1 || pos > pArr->len)
        return false;
    *val = pArr->pBase[pos-1];
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//查找元素的下标
int FindPosArray(struct Array* pArr,int val)//查找返回元素的下标若为-1时不存在
{
    int pos = -1;
    int i;
    if(NULL == pArr)
        return -1;//健壮性
    for(i = 0;i<pArr->len;i++)
    {
        if(pArr->pBase[i] == val)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//通过元素值删除元素
bool DeleteByValueArray(struct Array* pArr,int val)//删除通过值
{
    int i,pos;
    if(NULL == pArr)
        return false;
    pos = FindPosArray(pArr,val);
    pos = pos+1;//将下标转化成位置
    if(pos<1 || pos > pArr->len)
        return false;
    for(i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//翻转
void InversionArray(struct Array* pArr)
{

    int i = 0;
    int j = pArr->len-1;//数组最后一个元素的下标
    int t;//定义临时变量用于交换的的中间值
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
        return;
    while(i<j)
    {
        if(pArr->pBase[i] == pArr->pBase[j])//如果两个数相同不用交换
            break;
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }
}
//排序
void SortArray(struct Array* pArr)//升序
{
    int i,j;
    int t;//用于交换的临时变量
    if(NULL == pArr)
        return ;
    for(i = 0;i<pArr->len-1;i++)//最大下标等于有效元素个数-1
    {
        for(j = i+1;j<=pArr->len-1;j++)
        {
            if(pArr->pBase[i] > pArr->pBase[j])
            {
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }
}
//根据下标获得某个位置的元素
int AtArray(struct Array* pArr, int index)
{
    if(NULL == pArr)
        return -1;//健壮性
    if(index<0 || index>pArr->len-1)//数组越界退出
        return -1;
    return pArr->pBase[index];
}

1.3.15清空

1.3.15.0思想
  • 1、数组的有效元素的个数等于0
    pArr->len = 0;
1.3.15.1代码实现

1.3.16释放

1.3.16.0思想
  • 释放手动开辟的空间
1.3.16.1代码实现
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void InitArray(struct Array* pArr,int capacity);//效果数组变量pBase指向一些后，数组里面不再是垃圾值
bool IsFull(struct Array* pArr);//判断是否为满
void AppendArray(struct Array* pArr,int val);//追加不满时追加
bool IsEmpty(struct Array* pArr);//判断数组是否为空
void ShowArray(struct Array* pArr);//输出数组的中的数据
int CapacityArray(struct Array* pArr);//计算数组的容量
int LengthArray(struct Array* pArr);//计算素组的长度有效元素的个数
bool InsertArray(struct Array* pArr,int pos,int val);//插入 pos的值是从1开始即下标为0时是第一个元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val); //删除：通过元素的位置删除一个元素
int FindPosArray(struct Array* pArr,int val);//查找返回元素的下标
bool DeleteByValueArray(struct Array* pArr,int val);//删除通过值
void InversionArray(struct Array* pArr);//翻转
void SortArray(struct Array* pArr);//升序
int AtArray(struct Array* pArr,int index);//通过下标获取元素的值
void ClearArray(struct Array* pArr);//清空数组
void DestoryArray(struct Array* pArr);//释放
struct Array
{
    int* pBase;
    int len;//当前数组有效元素的个数
    int capacity;//数组的容量capacity
};
void test()//测试函数
{
    struct Array arr;
    int i,c,val,vpos;
    InitArray(&arr,10);
    for(i = 5;i<10;i++)
    {
        AppendArray(&arr,i);
    }
    printf("======判断数组是否为空======\n\n");
    if(IsEmpty(&arr))
        printf("数组为空\n");
    else
        printf("数组不为空\n");
    printf("======打印数组中的元素======\n\n");
    ShowArray(&arr);
    printf("======数组的容量======\n\n");
    c = CapacityArray(&arr);
    printf("数组的容量为: %d\n",c);
    printf("======数组的长度======\n\n");
    printf("数组的长度为: %d\n",LengthArray(&arr));
    printf("======插入元素======\n");
    if(InsertArray(&arr,4,10))
        printf("插入成功!\n");
    else
        printf("插入失败!\n");
    ShowArray(&arr);
    printf("======通过位置删除第一个位置的元素======\n\n");
    if(DeleteByPosArray(&arr,1,&val))
        printf("删除成功\n删除的元素的值为:%d\n",val);
    else
        printf("删除失败\n");
    printf("删除第一个元素后的数组为：\n");
    ShowArray(&arr);
    printf("======查找元素的下标=====\n");
    vpos = FindPosArray(&arr,10);
    printf("元素10的下标为:%d\n",vpos);
    printf("======通过元素的值删除元素======\n");
    if(DeleteByValueArray(&arr,6))
        printf("删除值为6的元素成功\n");
    else
        printf("删除失败！\n");
    ShowArray(&arr);
    printf("======翻转======\n");
    InversionArray(&arr);
    ShowArray(&arr);
    printf("======升序排序======\n");
    SortArray(&arr);
    ShowArray(&arr);
    printf("下标为2的元素的值为：%d\n",AtArray(&arr,2));
    printf("=======清空数组=====\n");
    ClearArray(&arr);
    printf("=======释放数组=====\n");
    DestoryArray(&arr);//释放

    return ;
}


int main()
{
    test();
    return 0;
}
void InitArray(struct Array* pArr,int capacity)//效果数组变量pBase指向一数据些后，数组里面不再是垃圾值，并且设定数组的长度
{
    pArr->pBase = (int*)malloc(sizeof(int)*capacity);
    if(NULL == pArr->pBase)//判断内存是否分配成功
    {
        printf("内存分配失败");
        exit(-1);
    }
    pArr->capacity = capacity;
    pArr->len = 0;
    return ;//终止此函数
}
//判断是否为满
bool IsFull(struct Array* pArr)//判断是否为满
{
    if(NULL == pArr)
        return false;//健壮性
    if(pArr->capacity ==pArr->len)//数组长度和有效个数相同
    {
        return true;
    }
    else
    {
        return false;
    }
}
//追加
void AppendArray(struct Array* pArr,int val)//追加  条件不满时追加
{   if(NULL == pArr)
        return ;//健壮性
    if(IsFull(pArr))//满了就返回一个false程序运行结束
    {
        printf("数组已经满了没法追加");
        return ;
    }
    pArr->pBase[pArr->len] = val;
    (pArr->len)++;
    return ;
    /*有个难点len再初始函数中是零*/
}
//判断数组是否为空
bool IsEmpty(struct Array* pArr)//判断有效元素个数是否为0
{    
    if(NULL == pArr)
        return false;//健壮性
    if(0 == pArr->len)
        return true;
    else
        return false;
}
void ShowArray(struct Array* pArr)//输出数组的中的数据
{
    int i;
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
    {
        printf("动态数组为空");
        return;//退出函数
    }
    else
    {
        for(i = 0;i < pArr->len;i++)//有效元素个数为1时它的下标为0
            printf("第%d个元素即下标为%d的元素值为 %d\n",i+1,i,pArr->pBase[i]);
        printf("\n");
    }

}
int CapacityArray(struct Array* pArr)//计算数组的容量
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->capacity;
}
int LengthArray(struct Array* pArr)//计算素组的长度有效元素的个数
{
    if(NULL == pArr)
        return -1;//健壮性
    return pArr->len;
}
bool InsertArray(struct Array* pArr,int pos,int val)//插入位置pos的值是从1开始即那个位置的逻辑编号(下标/地址)为0是第一个元素
{
    int i;
    if(NULL == pArr)
        return false;//健壮性
    if(IsFull(pArr))
        return false;
    if(pos<1 || pos >pArr->len+1)
        return false;
    /*
    for(i = pArr->len;i>=pos;i--)
        pArr->pBase[i-1] = pArr->pBase[i-2];//把逻辑地址转换成物理地址
    par->Base[pos-1];*/
    for(i = pArr->len-1;i >= pos -1;i--)//把逻辑序号转化成物理序号
        pArr->pBase[i+1] = pArr->pBase[i];
    pArr->pBase[pos-1] =val;
    //pArr->pBase[i+1] =val;//适合在最后一个元素前面或最后一个元素的位置上插入在最后一个元素的后面就不行了
    (pArr->len)++;//有效值加一
    return true;
}
//通过位置删除元素
bool DeleteByPosArray(struct Array* pArr,int pos,int *val)
{

    if(NULL == pArr)
        return false;//健壮性
    if(IsEmpty(pArr))
        return false;
    if(pos<1 || pos > pArr->len)
        return false;
    *val = pArr->pBase[pos-1];
    for(int i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//查找元素的下标
int FindPosArray(struct Array* pArr,int val)//查找返回元素的下标若为-1时不存在
{
    int pos = -1;
    int i;
    if(NULL == pArr)
        return -1;//健壮性
    for(i = 0;i<pArr->len;i++)
    {
        if(pArr->pBase[i] == val)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//通过元素值删除元素
bool DeleteByValueArray(struct Array* pArr,int val)//删除通过值
{
    int i,pos;
    if(NULL == pArr)
        return false;
    pos = FindPosArray(pArr,val);
    pos = pos+1;//将下标转化成位置
    if(pos<1 || pos > pArr->len)
        return false;
    for(i = pos;i<pArr->len;i++)
    {
        pArr->pBase[i-1] = pArr->pBase[i];//逻辑地址转换成物理地址
    }
    pArr->len--;
    return true;

}
//翻转
void InversionArray(struct Array* pArr)
{

    int i = 0;
    int j = pArr->len-1;//数组最后一个元素的下标
    int t;//定义临时变量用于交换的的中间值
    if(NULL == pArr)
        return ;//健壮性
    if(IsEmpty(pArr))
        return;
    while(i<j)
    {
        if(pArr->pBase[i] == pArr->pBase[j])//如果两个数相同不用交换
            break;
        t = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = t;
        i++;
        j--;
    }
}
//排序
void SortArray(struct Array* pArr)//升序
{
    int i,j;
    int t;//用于交换的临时变量
    if(NULL == pArr)
        return ;
    for(i = 0;i<pArr->len-1;i++)//最大下标等于有效元素个数-1
    {
        for(j = i+1;j<=pArr->len-1;j++)
        {
            if(pArr->pBase[i] > pArr->pBase[j])
            {
                t = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = t;
            }
        }
    }
}
//根据下标获得某个位置的元素
int AtArray(struct Array* pArr, int index)
{
    if(NULL == pArr)
        return -1;//健壮性
    if(index<0 || index>pArr->len-1)//数组越界退出
        return -1;
    return pArr->pBase[index];
}
//清空
void ClearArray(struct Array* pArr)//清空数组
{
    if(NULL == pArr)
        return;//健壮性
    pArr->len = 0;
}
//释放
void DestoryArray(struct Array* pArr)//释放
{
     if(NULL == pArr)
         return;//健壮性
     free(pArr->pBase);
     if(NULL != pArr->pBase)
         pArr->pBase = NULL;
}

运行结果:
这里写图片描述

1.3顺序表的应用

  • 说明这里删除是按照元素的下标进行删除的
    声明头文件：
#ifndef DYNAMIC_ARRAY_H//防止头文件被重复包含
#define DYNAMIC_ARRAY_H
//动态增长内存，策略，将存放数据的内存放到  堆上
//动态数组，申请内存，拷贝内存，释放内存6，插入第七个  capacity容量即数组的长度
//size记录当前数组的具体元素的个数
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
typedef struct DYNAMICARRAY{
    int* pArrDdr;
    int size;//有效元素个数
    int capacity;//
}Dynamic_Array;
//写一些对数组的操作
//初始化
Dynamic_Array* Init_Array();
//插入
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 Free_Arry(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 index);
#endif

框架的实现：

#include"DynamicArray.h"
//初始化数组
Dynamic_Array* Init_Array(){
    Dynamic_Array* myArray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));
    myArray->size = 0;
    myArray->capacity = 20;
    myArray->pArrDdr =(int*) malloc(sizeof(int)*myArray->capacity);
    return myArray;
}
//插入
void PushBack_Array(Dynamic_Array* arr, int value){
    if(NULL == arr){
        return;
    }//让程序健壮
    if(arr->size == arr->capacity)//判断空间是否够
    {
        int* newSpace = (int*)malloc(sizeof(int)*arr->capacity*2);//申请更大的内存空间
        memcpy(newSpace,arr->pArrDdr,arr->capacity*sizeof(int));//拷贝数据到新空间
        free(arr->pArrDdr);//释放旧空间
        arr->capacity = arr->capacity*2;//更新容量
        arr->pArrDdr = newSpace;//更新地址
    }
    arr->pArrDdr[arr->size] = value;//回到初始化看，下标从零开始不需加1
    arr->size++;

}
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos){
    int i;
    if(NULL == arr){
        return;
    }
    for(i = pos; i < arr->size-1;i++)
    {
        arr->pArrDdr[i] = arr->pArrDdr[i+1];
    }
    arr->size--;
}
//查找 返回值value所在的位置
int  Find_Array(Dynamic_Array* arr, int value){
    int pos = -1;
    int i;
    if(NULL == arr){
        return -1;
    }
    for(i = 0;i<arr->size;i++)
    {
        if(arr->pArrDdr[i] == value)
        {
            pos = i;
            break;
        }
    }
    return pos;

}
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value){
    int pos;
    if(NULL == arr){
        return;
    }
    //找元素的位置
    /*int pos = -1;
    for(int i = 0;i<arr->size;i++)
    {
        if(arr->pArrDdr[i] == value)
        {
            pos = i;
            break;
        }
    }*/
    pos = Find_Array(arr,value);
    RemoveByPos_Array(arr, pos);


}
//查找

//打印
void Print_Array(Dynamic_Array* arr){
    int i;
    if(NULL == arr){
        return;
    }//让程序健壮

    for(i = 0;i<arr->size;i++)
    {
        printf(" %d",arr->pArrDdr[i]);
    }
    printf("\n");

}
//释放
void Free_Arry(Dynamic_Array* arr){
    if(NULL == arr){
        return;
    }
    if(NULL != arr->pArrDdr){
        free(arr->pArrDdr);
    }

    free(arr);


}
//清空数组
void Clear_Array(Dynamic_Array* arr){
    if(NULL == arr){
        return;
    }
    arr->size = 0;

}
//获得动态数组的容量
int Capacity_Array(Dynamic_Array* arr){
    if(NULL == arr){
        return -1;
    }
    return arr->capacity;

}
//获得动态数组的当前元素个数
int Size_Array(Dynamic_Array* arr){
    if(NULL == arr){
        return -1;
    }
    return arr->size;

}
//根据下标获得某个位置的元素
int At_Array(Dynamic_Array* arr, int index){
    if(index<0 || index>arr->size-1)//
        return -1;
    return arr->pArrDdr[index];

}

使用：

#define _CRT_SECURE_NO_WANING
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"DynamicArray.h"
void test_Insert()
{
    int i;
    //初始化动态数组
    Dynamic_Array* myArray = Init_Array();
    //插入元素
    for(i = 0;i<10;i++)
    {
        PushBack_Array(myArray,i);
    }
    //打印
    Print_Array(myArray);
    //销毁
    Free_Arry(myArray);
}
void test_CapFin(){
    int i;
    int pos;
    //初始化动态数组
    Dynamic_Array* myArray = Init_Array();

    //打印容量
    printf("数组的容量：%d\n",Capacity_Array(myArray));
    //打印数组元素的个数
    printf("数组的元素的个数%d\n",Size_Array(myArray));

    //插入元素
    for(i = 0;i<35;i++)
    {
        PushBack_Array(myArray,i);
    }

    //打印容量
    printf("数组的容量：%d\n",Capacity_Array(myArray));
    //打印数组元素的个数
    printf("数组的元素的个数%d\n",Size_Array(myArray));
    //打印
    Print_Array(myArray);

    //根据下标删除第一个位置的元素
    RemoveByPos_Array(myArray,1);
    //根据值删除值为30的元素
    RemoveByValue_Array(myArray,30);
    //打印
    printf("删除第一个位置和值为30的元素后的数组为\n");
    Print_Array(myArray);


    //查找6元素的位置（下标）
    pos = Find_Array(myArray,6);
    printf("6查找到：pos：%d %d\n", pos, At_Array(myArray,pos));

    //销毁
    Free_Arry(myArray);

}
int main()
{
    printf("测试插入\n");
    test_Insert();
    printf("\n\n\n");
    test_CapFin();
    system("pause");
    return 0;
}

运行结果；
这里写图片描述

猜你喜欢

转载自blog.csdn.net/boy_of_god/article/details/81939396
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022