数组存储训练：初始化；追加元素；插入元素；删除元素；判断是否为空；判断是否满员；输出整个数组的元素；排序（冒泡）；倒序。

数组存储训练

# include<stdio.h>
# include<malloc.h>	 // 包含了malloc函数	
# include<stdlib.h>  // 包含了exit函数

// 定义了一个数据类型，该数据类型的名字叫做struct Arr，该数据类型含有三个成员；
struct Arr
{
	int * pBase;	// 存储的是数组的第一个元素的地址
	int len;		// 数组所能容纳的最大元素的个数
	int cnt;		// 当前数组有效元素的个数
};

void init_arr(struct Arr * pArr, int length);
bool append_arr(struct Arr * pArr, int val);
bool insert_arr(struct Arr * pArr, int pos, int val); // pos为插入的位置，pos从1开始，表示为在第pos个元素前面插入元素
bool delete_arr(struct Arr * pArr, int pos, int * pval);
bool is_empty(struct Arr * pArr);
bool is_full(struct Arr * pArr);
void sort_arr(struct Arr * pArr);
void show_arr(struct Arr * pArr);
void inversion_arr(struct Arr * pArr);


int main(void)
{
	struct Arr arr;
	int val;


	init_arr(&arr, 6);
	
	append_arr(&arr, 1);
	append_arr(&arr, 23);
	append_arr(&arr, -5);
	append_arr(&arr, 12);
	append_arr(&arr, 5);
	append_arr(&arr, 9);
//	for(int i = 0; i < arr.len; i++)
//		printf("arr.pBase[%d] = %d\n", i, arr.pBase[i]);
//	insert_arr(&arr, 1, 99);
//	inversion_arr(&arr);

	if(delete_arr(&arr, 2, &val))
	{
		show_arr(&arr);
		printf("val = %d\n", val);
	}


//	sort_arr(&arr);
	
//	if( append_arr(&arr, 6) )
//		printf("追加成功!\n");
//	else
//		printf("超出数组长度!\n");
	return 0;
};



void init_arr(struct Arr * pArr, int length)
{
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase)
	{
		printf("动态内存分配失败!\n");
		exit(-1);	//终止整个程序
	}
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	}
	return ;
}


bool is_empty(struct Arr * pArr)
{
	if(0 == pArr->cnt)
		return true;
	else
		return false;
}


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

}


bool append_arr(struct Arr * pArr, int val)
{
	// 满时返回false；
	if( is_full(pArr) )
		return false;
	// 不满时追加；
	else
	{
		pArr->pBase[pArr->cnt] = val;
		pArr->cnt++;
		return true;
	}
}


bool is_full(struct Arr * pArr)
{
	if(pArr->cnt == pArr->len)
		return true;
	else
		return false;
}

bool insert_arr(struct Arr * pArr, int pos, int val)
{
	if( is_full(pArr) )
		return false;
	if ( pos < 1 || pos > (pArr->cnt)+1 )
		return false;

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

bool delete_arr(struct Arr * pArr, int pos, int * pval)
{
	if( is_empty(pArr) )
		return false;
	if( pos < 1 || pos > pArr->cnt )
		return false;
	*pval =  pArr->pBase[pos-1];
	for(int i = pos; i < pArr->cnt; i++)
		pArr->pBase[i-1] = pArr->pBase[i];
	pArr->cnt--;
	return true;
}

/* 
void inversion_arr(struct Arr * pArr)       //倒序第一种方法
{
	int t;
	int k=0;
	for (int i = pArr->cnt-1; i > (pArr->cnt-1)/2; i--)
	{
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[k];
		pArr->pBase[k] = t;
		k++;
	}
	return;		
}
*/

void inversion_arr(struct Arr * pArr)
{
	int t;
	int i = 0;
	int j = pArr->cnt-1;
	while(i < j)
	{
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		i++;
		j--;
	}
}


void sort_arr(struct Arr * pArr) // 冒泡排序
{
	int i, j, t;
	for(i = 0; i < pArr->cnt; i++)
	{
		for(j = i+1; j < pArr->cnt; j++)
		{
			if(pArr->pBase[i] < pArr->pBase[j])
			{
				t = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = t;
			}
		}
	}
	return;
}