连续存储数组

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

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);//插入数组
 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();//排序 
 void show_arr(struct Arr * pArr);//输出数组 
 void inversion_arr(struct Arr * pArr); //倒置 
 
 int main(void)
 {
 	struct Arr pArr;
 	int val;
 	
 	init_arr(&pArr,6); 
 	
 	append_arr(&pArr, 1);
 	append_arr(&pArr, 2);
 	append_arr(&pArr, 3);
 	append_arr(&pArr, 4);
 	append_arr(&pArr, 5);
 	append_arr(&pArr, 6);
 	
 	insert_arr(&pArr,3,99);
 	
 	delete_arr(&pArr,1,&val);
 	show_arr(&pArr);
 	
 	inversion_arr(&pArr);
 	show_arr(&pArr);
 	
 	return 0;
  } 
  
  /*数组初始化*/
  void init_arr(struct Arr *pArr, int length)
  {
  	pArr->pBase = (int*)malloc(length*sizeof(int));//1.动态内存分配 
  	if(NULL == pArr->pBase)//2.判断数组是否为空 ，不为空赋值 
  	{
  		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;
   } 
   
   //判断数组是否溢出 
   bool is_full(struct Arr * pArr){
   	if(pArr->len == 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\t",pArr->pBase[i]);	
			   }
		   	
		   } 
		   	
   } 
   
   //追加操作 
   bool append_arr(struct Arr * pArr, int val){
   		
   		//满时返回false 
	   if(is_full(pArr))
	   return false;
	   //不满时追加 
	   
	   	pArr->pBase[pArr->cnt] = val;
		(pArr->cnt)++; 
		return true; 
	   
   }
   
   //插入操作 
   bool insert_arr(struct Arr * pArr, int pos, int val){
   	int i; 
   	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;	 
	pArr->cnt ++; 
		
	return true;	
   }
   
   /*删除操作*/
bool delete_arr(struct Arr * pArr, int pos, int *pVal) 
   {
   	int i;
   	if(is_empty(pArr))
   		return false;
   	if(pos<1 || pos>pArr->cnt)
   		return false;
   		
   	*pVal = pArr->pBase[pos-1];
   	for(i=pos; i<pArr->cnt;i++ ){
   		pArr->pBase[i-1] = pArr->pBase[i];
	   } 
	pArr->cnt--;
	
	return true;
   }
   
   //倒置
   void inversion_arr(struct Arr * pArr) 
   {
   	int i = 0;
   	int j = pArr->cnt-1;
	int t;
	
	while(i < j){
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		++i;
		--j;
	} 
	return;
   }
   
   //排序（冒泡） 
   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;
			   }
		   }
	   }
   }