线性表（顺序表功能实现）

最新推荐文章于 2022-10-28 21:06:49 发布

charming_guy

最新推荐文章于 2022-10-28 21:06:49 发布

阅读量277

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/boy_of_god/article/details/100129167

版权

数据结构专栏收录该内容

5 篇文章 2 订阅

订阅专栏

第一篇我的线性表原来我把整个线性表的调试过程以及代码形成的过程都写下来了，过程非常繁厚，在回顾的时候发现太麻烦，我都有点晕。这里就没有只有功能函数了。

文章目录

线性表
1.3顺序表的应用（功能函数的封装比考研更灵活）

线性表

线性表的顺序存储(顺序表)
线性表的链式存储（链表）
线性表的定义：
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 功能代码：

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 功能代码：

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 功能代码：

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.2.1功能代码：

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功能代码

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功能代码

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功能代码

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、代码实现


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、功能代码

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功能代码

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功能代码

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.3功能代码

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、功能代码

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、功能代码

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功能代码

void ClearArray(struct Array* pArr)//清空数组
{
	if(NULL == pArr)
		return;//健壮性
	pArr->len = 0;
}

1.3.16释放

1.3.16.0思想

释放手动开辟的空间

1.3.15.1功能代码

//释放
void DestoryArray(struct Array* pArr)//释放
{
    if(NULL == pArr)
        return;//健壮性
    free(pArr->pBase);
    if(NULL != pArr->pBase)
   	 pArr->pBase = NULL;
}

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;
}

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

charming_guy

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
线性表（顺序表功能实现）

文章目录线性表1、顺序表（动态数组）1.1、定义：1.2、算法1.3实现1.3.0定义数据类型1.3.1初始化1.3.1.0思想1.3.1.1 功能代码：1.3.2判断是否满1.3.2.0思想1.3.2.1 功能代码：1.3.3追加1.3.3.0思想1.3.3.1 功能代码：1.3.4判断是否为空1.3.4.0思想1.3.2.1功能代码：1.3.5输出数组1.3.5.0思想1.3.5.1功...
复制链接

扫一扫