数据结构--连续内存分配的实现

数据结构存储：

struct Arr {
	int *pBase;
	int len;
	int cnt;
};

数据结构操作：

void init_arr(struct Arr *pArr, int length);		//首先进行的是初始化数组
int is_empty(struct Arr *pArr);					//判断数组是否为空 return 0 1 
int is_full(struct Arr *pArr);						//判断数据是否满 这样才能插入和删除数据  return 0 1 
int append_arr(struct Arr *pArr, int val);			//在数组中追加数据  return 0 1 
void show_arr(struct Arr *pArr);					//显示数据
int insert_arr(struct Arr *pArr,int pos,int val);	//在指定位置插入数据  pos从1开始  return 0 1 
int delete_arr(struct Arr *pArr, int pos,int* pVal);/*删除pos的数据 并将数据返回到pVal中 return 0 1 这里并不能使用return返回删除的值 如果删除元素为0 会引起误会*/
int get(struct Arr *pArr,int pos,int *pVal);		//获得指定位置的数值
void sort_arr(struct Arr *pArr);					//将数组中的元素按照从小到大的顺序排序
void inverse_arr(struct Arr *pArr);				//数组的反转

具体代码实现：

#include<stdio.h>//标准输入输出函数
#include<stdlib.h>  //使用 的是exit（）函数
/*
*  Q:在这里可以挖掘  标准的输入输出函数是怎样实现的？？
*/

#include<malloc.h>//系统级别的动态分配函数  

/*
*定义：连续存储 也就是系统分配一块连续的内存空间  习惯上称为数组
*特点： 1.数组元素相同 大小相等
*		2.具有连续的内存空间，且大小固定
*/

/*数据存储方式
*
*连续的内存空间  有一个指针 *pBase
*数组大小固定    有一个数组总大小 len
*				 有效元素的数量 cnt
*/

struct Arr {
	int *pBase;
	int len;
	int cnt;
};

//数据的操作
void init_arr(struct Arr *pArr, int length);		//首先进行的是初始化数组
int is_empty(struct Arr *pArr);					//判断数组是否为空 return 0 1 
int is_full(struct Arr *pArr);						//判断数据是否满 这样才能插入和删除数据  return 0 1 
int append_arr(struct Arr *pArr, int val);			//在数组中追加数据  return 0 1 
void show_arr(struct Arr *pArr);					//显示数据
int insert_arr(struct Arr *pArr,int pos,int val);	//在指定位置插入数据  pos从1开始  return 0 1 
int delete_arr(struct Arr *pArr, int pos,int* pVal);/*删除pos的数据 并将数据返回到pVal中 return 0 1 这里并不能使用return返回删除的值 如果删除元素为0 会引起误会*/
int get(struct Arr *pArr,int pos,int *pVal);		//获得指定位置的数值
void sort_arr(struct Arr *pArr);					//将数组中的元素按照从小到大的顺序排序
void inverse_arr(struct Arr *pArr);				//数组的反转
/*

*/

//主函数
int main() {
	struct Arr arr;
	int val = 0;
	init_arr(&arr, 6);
	append_arr(&arr, 0);
	append_arr(&arr, 1);
	append_arr(&arr, 2);
	append_arr(&arr, 3);
	append_arr(&arr, 4);
	show_arr(&arr);
	insert_arr(&arr, 1, 1);
	show_arr(&arr);
	delete_arr(&arr, 6, &val);
	show_arr(&arr);
	sort_arr(&arr);
	show_arr(&arr);
	inverse_arr(&arr);
	show_arr(&arr);
	return 0;
}

void init_arr(struct Arr *pArr, int length) {
	//初始化数组  分配地址和长度
	pArr->pBase = (int*)malloc(sizeof(int)*length);
	if (NULL == pArr->pBase) {
		exit(-1);
	}
	memset(pArr->pBase, 0, sizeof(int)*length);
	pArr->len = length;
	pArr->cnt = 0;

	return;//****写作习惯
}


int is_empty(struct Arr *pArr) {
	if (0 == pArr->len)
		return 1;
	else
		return 0;
}

int is_full(struct Arr *pArr) {
	if (pArr->cnt == pArr->len) {
		return 1;
	}
	else
	{
		return 0;
	}
}

int append_arr(struct Arr *pArr, int val) {
	if (is_full(pArr)) {
		printf("数组已满！\n");
		return 0;
	}

	pArr->pBase[pArr->cnt] = val;
	pArr->cnt++;
	return 1;
}

void show_arr(struct Arr *pArr) {
	if (is_empty(pArr)) {
		printf("数组为空\n");
		return;
	}
	else {
		for (int i = 0; i < pArr->cnt; i++) {
			printf("%d  ", pArr->pBase[i]);
		}
		printf("\n");
	}
	return 0;
}

int insert_arr(struct Arr *pArr, int pos, int val) {
	if (is_full(pArr)) {
		printf("数组已满！\n无法插入");
		return 0;
	}
	if (pos  < 1 || pos > pArr->len) {
		printf("插入位置不正确！\n");
		return 0;
	}
	for (int i = pArr->cnt-1; i >= pos - 1; i--) {
		pArr->pBase[i + 1] = pArr->pBase[i];
	}
	pArr->pBase[pos - 1] = val;
	pArr->cnt++;
	return 1;
}

int delete_arr(struct Arr *pArr, int pos, int* pVal) {
	if (is_empty(pArr)) {
		printf("数组为空！\n无法删除");
		return 0;
	}
	if (pos  < 1 || pos > pArr->cnt) {
		printf("删除位置不正确！\n");
		return 0;
	}

	*pVal = pArr->pBase[pos - 1];

	if (pos == pArr->len) {
		pArr->pBase[pos - 1] = 0;
	}
	else {

		for (int i = pos - 1; i <= pArr->cnt - 1; i++) {
			pArr->pBase[i] = pArr->pBase[i + 1];
		}
	}
	pArr->cnt--;
	return 1;
}

int get(struct Arr *pArr, int pos, int *pVal) {
	if (is_empty(pArr)) {
		printf("数组为空！\n");
		return 0;
	}
	if (pos  < 1 || pos > pArr->cnt) {
		printf("位置不正确！\n");
		return 0;
	}
	pVal = pArr->pBase[pos - 1];
	return 1;
}

void sort_arr(struct Arr *pArr) {
	int temp;

	for (int i = 0; i < pArr->cnt - 1; i++) { 
		int k = i;
		for (int j = i+1; j < pArr->cnt; j++) {
			if (pArr->pBase[k] > pArr->pBase[j]) {
				k = j;
			}
		}
		if (i != k) {
			temp = pArr->pBase[k];
			pArr->pBase[k] = pArr->pBase[i];
			pArr->pBase[i] = temp;
		}
	}
}

void inverse_arr(struct Arr *pArr) {
	int temp;
	int i = 0, j = pArr->cnt - 1;
	for (i, j; i < j; i++, j--) {
		temp = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = temp;
	}
}