郝斌数据结构——数组

郝斌数据结构——数组

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

/*
	定义结构体
*/
struct Arr
{
	int* first; // 存储的是数组第一个元素的地址
	int len; //数组的最大容量
	int cen;   //当前数组元素的个数
};

/*
	初始化数组
*/
void init_arr(struct Arr* pArr, int length) {

	// 动态分配内存，将内存的首地址保存到数组首元素中。
	pArr->first = (int*)malloc(sizeof(int) * length); 

	if (pArr->first==NULL) {  // 分配是否成功
		printf("动态分配内存失败！");
		exit(-1);//退出程序
	}
	else {
		//分配成功的话
		pArr->len = length;
		pArr->cen = 0;
	}
}

/*
	数组当前是否为空
*/
bool is_empty(struct Arr* pArr) {
	if (pArr->cen == 0) {	//数组中有效元素的个数为0，则为空
		return true;
	}
	return false;
}



/*
	打印数组内容
*/
void show(struct Arr* pArr) {
	if (is_empty(pArr)) {
		printf("数组为空！");
		return;
	}
	else{
		for (int i = 0; i < pArr->cen; i++) {
			//printf("%d\t", *(pArr->first + i));
			printf("%d\t", pArr->first[i]);
			//pArr->first是数组首地址，就相当于是数组名，可以在后面跟[i]
			printf("\n");
		}
	}
}



/*
	数组是否满了
*/
bool is_full(struct Arr* pArr) {
	if (pArr->len == pArr->cen) {
		printf("数组满了！");
		return true;
	}
	return false;

}



/*
	数组最后追加元素
*/
bool append_arr(struct Arr* pArr, int val) {
	if (is_full(pArr))
		return false;
	pArr->first[pArr->cen] = val;
	//pArr->first是数组首地址，pArr->cen是要追加元素的下标。

	(pArr->cen)++;//追加元素后，cen个数要+1。
	return true;
}



/*
	数组某个位置插入元素
*/
bool insert_arr(struct Arr* pArr, int pos, int val) {	//pos从1开始
	if (is_full(pArr))
		return false;

	if (pos<1 || pos>pArr->cen + 1) { 
		//可以在最后一个元素的后一个位置插入，后两个不行
		printf("插入位置错误！");
		return false;
	}

	//要插入元素，需要先从最后一个元素开始给他后挪一位，
	for (int i = pArr->cen; i >= pos; i--) {  
		pArr->first[i] = pArr->first[i - 1];
	}
	pArr->first[pos - 1] = val;
	pArr->cen++;  //不要加括号，先进行指针运算，后进行自增运算
	return true;
}




/*
	删除数组某个位置的元素
*/
bool delete_arr(struct Arr* pArr, int pos, int* pVal) { //pos从1开始
	if (is_empty(pArr))
		return false;

	if (pos<1 || pos>pArr->cen)
		printf("删除数据的位置有误（从1开始）！");

	//如果需要用的删除的数据，可以用指针变量进行接受并返回
	*pVal = pArr->first[pos - 1];

	//从要删除元素的后一个元素开始，使用后面的元素把前面的元素覆盖掉
	for (int i = pos; i <= pArr->cen-1; i++) {
		pArr->first[i - 1] = pArr->first[i];
	}
	pArr->cen--;
	return true;

}




/*
	获取数组某个位置的元素
*/
bool get(struct Arr* pArr, int pos, int* pVal) {
	if (is_empty(pArr))
		return false;

	if (pos<1 || pos>pArr->cen)
		return false;

	*pVal = pArr->first[pos - 1];
	return true;
}




/*
	反转数组元素
*/
bool innversion_arr(struct Arr* pArr) {
	if (is_empty(pArr))
		return false;

	for (int i = 0; i < pArr->cen / 2; i++) {
		int temp = pArr->first[i];
		pArr->first[i] = pArr->first[pArr->cen - i - 1];
		pArr->first[pArr->cen - i - 1] = temp;
	}
	return true;
}



/*
	选择排序：
			  两层遍历，遇到更小的数就交换两数
			  第一次内循环结束会得到一个最小的数
*/
void sort(struct Arr* pArr) {
	for (int i = 0; i < pArr->cen; i++){
		for (int j = i+1; j < pArr->cen; j++){
			if (pArr->first[j] < pArr->first[i]) {
				int temp = pArr->first[j];
				pArr->first[j] = pArr->first[i];
				pArr->first[i] = temp;
			}
		}
	}
}




/*
	测试程序
*/
int main() {
	struct Arr pArr;	//不能定义结构体指针，不然没有指向
	init_arr(&pArr, 7);	//应该定义结构体类型变量，调用初始化函数，传入变量地址

	append_arr(&pArr, 34);
	append_arr(&pArr, 16);
	append_arr(&pArr, 63);
	append_arr(&pArr, 25);
	insert_arr(&pArr, 3, 44);
	int pVal;  
	//定义一个int类型数据，传参时传的是指针；
	//不能定义成int*，不然没有指向
	delete_arr(&pArr, 1, &pVal);

	show(&pArr);
	printf("数组长度：%d\n有效元素个数：%d\n", pArr.len,pArr.cen);
	printf("删除的数据：%d\n", pVal);

	int val=0;
	get(&pArr, 4, &val);
	printf("第%d个元素是%d\n", 4, val);


	printf("反转后的数组为：\n");
	innversion_arr(&pArr);
	show(&pArr);

	printf("排序后的数组为：\n");
	sort(&pArr);
	show(&pArr);

	return 0;
}

结果：