连续存储【数组】的定义及使用（附带实现代码）

连续存储【数组】

1.数组的定义

元素类型相同，大小相等

数组的特点

• 在内存中，数组是一块连续的区域。
• 数组需要预留空间，在使用前要先申请占内存的大小，可能会浪费内存空间。
• 插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。
• 随机读取效率很高。因为数组是连续的，知道每一个数据的内存地址，可以直接找到给定地址的数据。
• 并且不利于扩展，数组定义的空间不够时要重新定义数组。

2.数组的优缺点

（1）数组的优点

• 随机访问性强
• 查找速度快

（2）数组的缺点

• 插入和删除效率低
• 可能浪费内存
• 内存空间要求高，必须有足够的连续内存空间。
• 数组大小固定，不能动态拓展

3.数组的实现

（1）主函数和函数声明

#include <stdio.h> 
#include <malloc.h>
#include <stdlib.h>
typedef struct Arr//定义了一个结构类型叫struct Arr，该数据类型含有三个成员
{
	int* pBase;//存储数组第一个元素的地址
	int listsize;//数组容量，数组所能容纳的最大元素的个数
	int len;//当前数组有效元素的个数
	//int increment;//自动增长因子
}Arr,*pArr;//起别名,Arr == struct Arr, pArr == struct Arr*

void init_arr(pArr a);//初始化
bool append_arr(pArr a, int val);//追加元素
bool insert_arr(pArr a, int pos, int val);//插入到指定位置前面,pos值从1开始
bool delete_arr(pArr a, int pos, int* pVal);//删除,int*pVal接收删除的值
bool get_arr(pArr a, int pos, int* pVal);//得到某个位置的元素
bool is_empty(pArr a);//是否为空
bool is_full(pArr a);//是否为满
void sort_arr(pArr a);//排序
void show_arr(pArr a);//显示
void inversion_arr(pArr a);//倒置

int main() 
{
	Arr arr;
	init_arr(&arr);
	int val;
	int pos;
	int i;

	//追加
	while (true)
	{
		printf("请输入想要追加的元素：");
		scanf_s("%d", &val);
		append_arr(&arr, val);
		printf("是否继续追加的元素：yes:1,no:2：");
		scanf_s("%d", &i);
		if (i == 2)
		{
			break;
		}
	}
	printf("追加后：");
	show_arr(&arr);//打印数组

	//插入
	printf("请输入需要插入的位置：\n");
	scanf_s("%d", &pos);
	printf("请输入需要插入的值：\n");
	scanf_s("%d", &val);
	if (insert_arr(&arr, pos, val))
	{
		printf("插入成功");
	}
	printf("插入后：");
	show_arr(&arr);

	//删除
	printf("请输入需要删除的位置：\n");
	scanf_s("%d", &pos);
	if (delete_arr(&arr, pos, &val))
	{
		printf("删除成功，删除的值为%d\n", val);
	}
	printf("删除后：");
	show_arr(&arr);

	//查找
	printf("请输入需要查找的位置：\n");
	scanf_s("%d", &pos);
	if (get_arr(&arr, pos, &val))
	{
		printf("查找成功，a[%d]=%d\n", pos, val);
	}

	//倒置数组
	inversion_arr(&arr);
	printf("倒置后：");
	show_arr(&arr);

	//排序
	sort_arr(&arr);
	printf("从小到大排序后：");
	show_arr(&arr);
	return 0;
}

（2）分配地址初始化

void init_arr(pArr a)//初始化
{
	printf("请输入数组容量\n");
	scanf_s("%d", &a->listsize);//初始化数组容量
	printf("数组容量为：%d\n", a->listsize);
	a->pBase = (int*)malloc(sizeof(int) * a->listsize);
	if (NULL == a->pBase) {
		printf("动态内存分配失败！\n");
		exit(-1);//表示终止整个程序
	}
	else
	{
		a->len = 0;//当前数组有效元素的个数为0
	}
	return;
}

（3）追加元素

bool append_arr(pArr a, int val)//追加元素
{

	if (is_full(a))//如果数组为满返回false
	{
		printf("数组为满，追加失败\n");
		return false;
	}
	else
	{
		a->pBase[a->len] = val;
		a->len++;
		printf("追加成功\n");
	}

	return true;
}

（4）插入元素

bool insert_arr(pArr a, int pos, int val)//插入
{
	if (is_full(a))
	{
		printf("内存不够");
		return false;
	}
	if (pos < 1 || pos > a->len + 1)
	{
		printf("pos值不合法");
		return false;
	}
	for (int i = a->len - 1; i >= pos - 1; i--)//所有元素往后移
	{
		a->pBase[i + 1] = a->pBase[i];
	}
	a->pBase[pos - 1] = val;
	a->len++;
	return true;
}

（5）删除元素

bool delete_arr(pArr a, int pos, int* pVal)//删除
{
	if (is_empty(a))
	{
		printf("内存已满");
		return false;
	}
	if (pos < 1 || pos > a->len)
	{
		printf("pos值不合法");
		return false;
	}
	*pVal = a->pBase[pos - 1];
	for (int i = pos; i < a->len; i++)
	{
		a->pBase[i - 1] = a->pBase[i];
	}
	a->len--;
	return true;
}

（6）查找元素

bool get_arr(pArr a, int pos, int* pVal)//得到某个元素
{
	if (pos < 1 || pos > a->len)
	{
		printf("pos值不合法");
		return false;
	}
	*pVal = a->pBase[pos - 1];
	return true;
}

（7）判断空满

bool is_empty(pArr a)//是否为空
{
	if (a->len == 0)
		return true;
	else
		return false;
}
bool is_full(pArr a)//是否为满
{
	if (a->len == a->listsize)
		return true;
	else
		return false;
}

（8）排序

void sort_arr(pArr a)//排序
{
	int t;
	// 每次将一个元素送到末尾，n个元素，执行n次
	for (int i = 0; i < a->len; i++)
	{
		// 之前的循环已经将i个元素送到末尾，不需要再次比较，故减去，因为跟后一个元素比较，为了避免溢出，故减一
		for (int j = 0; j < a->len - 1 - i; j++)
		{
			if (a->pBase[j] > a->pBase[j + 1])
			{
				t = a->pBase[j];
				a->pBase[j] = a->pBase[j + 1];
				a->pBase[j + 1] = t;
			}
		}
	}
}

（9）打印所有元素

void show_arr(pArr a)//显示
{
	if (is_empty(a))//这时因为a本身已经是pArr类型，所以这里不需要加取地址符
		//如果数组为空，提示数组为空
		printf("数组为空\n");
	else
	{
		printf("数组元素为\n");
		for (int i = 0; i < a->len; i++)
			printf("a[%d]为：%d\n", i + 1, a->pBase[i]);//int *
		printf("\n");
	}
}

（10）倒置

void inversion_arr(pArr a)//倒置
{
	int i = 0;
	int j = a->len - 1;
	int t;
	while (i < j)
	{
		t = a->pBase[i];
		a->pBase[i] = a->pBase[j];
		a->pBase[j] = t;
		i++;
		j--;
	}
}