连续存储数组算法

连续存储

1.什么是数组

元素类型相同，大小相等

2.数组的优缺点：

 #include<stdio.h>
 #include<malloc.h>//包含了malloc 
 #include<stdlib.h> //包含了exit 
 struct Arr//定义了一个数据类型 ，名字叫 struct Arr，该数据类型含有三个成员 
 {
     int *pBase;//存储的数组第一个元素的地址 
     int len;//数组所能容纳的最大元素个数 
     int cnt;//当前数组有效的个数 
     //int increment;//自动增长因子 ,allocate,自动扩充 
 }; 
 void init_arr(struct Arr *pArr,int length);//初始化initialization ,分号不能少 
 bool append_arr();//追加 
 bool insert_arr(); 
 bool delete_arr();
 int  get();
 bool is_empty();
 bool is_full();
 void sort_arr();
 void show_arr(struct Arr*pArr);
 void inversion_arr();
 ​
 ​
 int main(void)
 {
     struct Arr arr; //还没有生成，调用init后会生成指向一个数组
     
     init_arr(&arr,6); 
     show_arr(&arr);
      //printf("%d\n",arr.len) ;
     return 0;
 }
 ​
 void init_arr(struct Arr *pArr,int length)
 {
     //(*pArr).len=99;//arr中的len并没有改变，会克隆一个来传递赋值 
     //通过地址来修改 
     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");
     }
     
 }

 #include<stdio.h>
 #include<malloc.h>//包含了malloc 
 #include<stdlib.h> //包含了exit 
 struct Arr//定义了一个数据类型 ，名字叫 struct Arr，该数据类型含有三个成员 
 {
     int *pBase;//存储的数组第一个元素的地址 
     int len;//数组所能容纳的最大元素个数 
     int cnt;//当前数组有效的个数 
     //int increment;//自动增长因子 ,allocate,自动扩充 
 }; 
 void init_arr(struct Arr *pArr,int length);//初始化initialization ,分号不能少 
 bool append_arr(struct Arr *pArr,int val);//追加 
 bool insert_arr(struct Arr *pArr,int pos,int val); //pos的值从1开始 
 bool delete_arr(struct Arr *pArr,int pos,int*pVal);
 int  get();
 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; //还没有生成，调用init后会生成指向一个数组
     int val;
     init_arr(&arr,6); 
     show_arr(&arr);
      //printf("%d\n",arr.len) ;
      append_arr(&arr,1); 
      append_arr(&arr,2);
      append_arr(&arr,3);
      append_arr(&arr,4);
      append_arr(&arr,5);
      if(delete_arr(&arr,1,&val))
      {
         printf("删除成功!\n");
         printf("删除的元素是：%d\n",val);
     
      }else{
         printf("删除失败！\n");
      }
      show_arr(&arr);
      inversion_arr(&arr);
      printf("倒置后为：\n");
      
      show_arr(&arr);
      sort_arr(&arr);
      printf("排序后为：\n");
      
      show_arr(&arr);
      
 //   insert_arr(&arr,6,99) ;
 //   
 //   append_arr(&arr,6);
 //   append_arr(&arr,7);
 //   append_arr(&arr,8);
      
 //   if(append_arr(&arr,8))
 //   {
 //      printf("追加成功\n");
 //   }
 //   else
 //   {
 //      printf("追加失败\n");
 //   }
 //   show_arr(&arr);
     return 0;
 }
 ​
 void init_arr(struct Arr *pArr,int length)
 {
     //(*pArr).len=99;//arr中的len并没有改变，会克隆一个来传递赋值 
     //通过地址来修改 
     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;
     }
 }
 bool is_full(struct Arr*pArr)
 {
     if(pArr->cnt==pArr->len)
     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]);
         printf("\n");
     }
     
 }
 bool append_arr(struct Arr *pArr,int val)
 {
     //满时返回false 
     if(is_full(pArr))
     {
         return false;
     }
     //不满时追加
     pArr->pBase[pArr->cnt] =val;
     (pArr->cnt)++;
 }
 //流程 功能 实数 
 ​
 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(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)
 {
     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--;
 }
 ​
 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;
     for(i=0;i<pArr->cnt;++i) 
     {
         for(j=i+1;j<pArr->cnt;++j)
         {
             if(pArr->pBase[i]>pArr->pBase[j])
             {
                 int t;
                 t=pArr->pBase[i];
         pArr->pBase[i] = pArr->pBase[j];
         pArr->pBase[j]=t;
             }
     
         }
     }
  }