数据结构：数组的操作（C语言描述）

最新推荐文章于 2023-01-14 18:56:18 发布
最新推荐文章于 2023-01-14 18:56:18 发布
阅读量1.3k 收藏 7
点赞数
分类专栏： 【Algorithms】

     数据的在计算机的存储方式分为：连续存储【数组】，非连续存储【链表、树、图and so on】;今天讨论的将是数组，包括数组的创建、打印输出，在数组后面追加元素，判断数组是否为空，判断数组是否为满，在数组的指定位置添加元素，在数组的指定位置删除元素，数组元素的倒置和数组元素的排序。对应的函数如下：

[cpp]  view plain  copy
  1. void Init_arr(struct Array *pArr,int len);//初始化数组  
  2. bool append_arr(struct Array *pArr,int val);//在数组后追加一个元素  
  3. bool Insert_arr(struct Array *pArr,int pos,int val);//指定位置插入元素  
  4. bool Delete_arr(struct Array *pArr,int pos,int *val);//指定位置删除元素  
  5.   
  6. bool IsFull_arr(struct Array *pArr);//判断数组是否满  
  7. bool IsEmpty_arr(struct Array *pArr);//判断数组是否空  
  8.   
  9. void show_arr(struct Array *pArr);//打印数组中的元素  
  10. void Inversion_arr(struct Array *pArr);//倒置数组中的元素  
  11. void SelectSort_arr(struct Array *pArr);//选择排序  
  12. void BubbleSort_arr(struct Array *pArr);//冒泡排序  

1.数组的组成元素

      我们知道确定一个数组，需要知道数组的首地址（pArr），数组的最大长度（len）以及数组当前元素个数；所以我们要做的第一件事就要新建一个数据类型

[cpp]  view plain  copy
  1. struct Array  
  2. {  
  3.    int *pBase; //定义一个指向数组的指针  
  4.    int len;    //数组中能够存放的最大元素个数  
  5.    int cnt;    //当前数组中元素的个数  
  6. };  

此时定义一个名为struct Array 的数据类型，只是定义了数据类型并没有分配内存；

[cpp]  view plain  copy
  1. struct Array arr;   //定义一个结构体变量，并分配内存在静态区；（静态区、堆，栈）  

定义一个变量时通常的格式：数据类型+变量名·（如：int a，定义一个整型变量a），此时定义了一个名为arr的结构体变量，并此变量分配了内存，指针pBase分配了4个字节，len变量分配了四个字节，cnt变量分配了4个字节；但是此时并没有为pBase指向的数组分配内存。因此，要想对数组进行操作，还必须分配一块内存。可以用sizeof函数来看实际分配了多少内存；

[cpp]  view plain  copy
  1. printf("字节数： %d",sizeof(struct Array));  

此时的输出是12，说明我们的判断并没有错；并没有为数组分配内存，只为结构体中的数据成员分配了内存。

       内存的分配三种方式：

（1）从静态存储区中分配，一般全局变量和static修饰的变量从静态区分配

（2）在栈上创建，局部变量的分配

（3）从堆上分配  ，用malloc函数申请内存时，从堆上进行分配   



2.数组的创建

   函数的一般注释格式：

/*********************************************************************************
  *Function:  //函数名称
  * Description：  //函数功能，性能等的描述
  *Calls:  //被本函数调用的函数清单
  *Called By:  //调用本函数的清单
  *Input:  //输入参数的说明，包括每个参数的作用、取值说明及参数间关系
  *Output:  //输出参数的说明
  *Return:  //函数返回值的说明
  *Others:  //其他说明
**********************************************************************************/

[cpp]  view plain  copy
  1. /********************************************************************************* 
  2.   *Function: Init_arr； 
  3.   *Description： 创建并初始化一个数组； 
  4.   *Calls:  malloc()、printf()、exit()； 
  5.   *Called By:  none 
  6.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  7.            参数——len是说明创建的数组的容量，也就是能装元素的最大个数； 
  8.           //输入参数的说明，包括每个参数的作用、取值说明及参数间关系； 
  9.   *Output:  none 
  10.   *Return:  none 
  11.   *Others:  none 
  12. **********************************************************************************/  
  13. void Init_arr(struct Array *pArr,int len)  
  14. {  
  15.       
  16.     pArr->pBase=(int *)malloc(sizeof(int)*pArr->len);  
  17.     if(NULL==pArr->pBase)  
  18.     {  
  19.         printf("分配内存失败");  
  20.         exit(-1);   //终止程序  
  21.           
  22.     }  
  23.     else  
  24.     {  
  25.        pArr->cnt=0;  
  26.        pArr->len=len;  
  27.     }  
  28.         return;  //加return的目的是为了告诉其他人，此函数到此已经写完了  
  29. }  

[cpp]  view plain  copy
  1. pArr->pBase=(int *)malloc(sizeof(int)*pArr->len);  
（1）用malloc( 参数1 )函数分配了一块内存，内存的大小是 参数1 的大小，并且指针pArr->pBase指向这块内存的首地址。很多人认为这是为指针 pArr->pBase分配了内存，这是不对的；对于32的系统，任何指针所在内存的大小都是4个字节，指针就是用来存放地址编号的，但存放指针内存的地址编号，往往我们不需要关心。

（2）用malloc()函数分配内存，若是分配成功，则会把这块内存的首地址赋给指针pArr->pBase；若是分配失败，会把NULL赋给指针；

[cpp]  view plain  copy
  1. if(NULL==pArr->pBase)  
  2.     {  
  3.         printf("分配内存失败");  
  4.         exit(-1);   //终止程序  
  5.           
  6.     }  

因此需要检查，内存分配失败，用函数 exit(-1) 函数退出程序。

（3）malloc函数的用法

void * malloc(int ); 函数的形参是一个整型数据，用来说明申请内存的大小，单位是字节。malloc函数的返回值是个void类型的指针，因此  往往需要强制转换所需要的类型指针；  例如，

[cpp]  view plain  copy
  1. pArr->pBase=(int *)malloc(sizeof(int)*pArr->len);  
就是强制转换成指向整型的的指针,(int *)(参数1)，就是把参数1强制转换成int * 类型；

3.插入一个元素

[cpp]  view plain  copy
  1. /********************************************************************************* 
  2.   *Function: Insert_arr； 
  3.   *Description： 在数组的第pos个元素前，插入val元素；； 
  4.   *Calls:  IsFull_arr()； 
  5.   *Called By: none； 
  6.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  7.            参数——pos，表示位置，在数组第pos元素前加入数据val； 
  8.            参数——val，表示要插入的数据； 
  9.   *Output:  none 
  10.   *Return:  布尔量，1表示插入成功；0，插入失败； 
  11.   *Others:  none 
  12. **********************************************************************************/  
  13. bool Insert_arr(struct Array *pArr,int pos,int val)  
  14. {  
  15.     int i;  
  16.     if(IsFull_arr(pArr))          //为空不能进行插入操作  
  17.         return false;  
  18.     if(pos<1||pos>pArr->cnt+1)  //插入的位置不能在第一个元素前面，也不可以在最后一个元素后面的后面插入  
  19.         return false;  
  20.       
  21.         for(i=pArr->cnt-1;i>=(pos-1);i--)  
  22.             pArr->pBase[i+1]=pArr->pBase[i];  
  23.         pArr->pBase[pos-1]=val;  
  24.         pArr->cnt++;  
  25.         return true;  
  26.   
  27. }  
可以往数组中指定位置插入一个元素，必须满足一定的条件：

（1）数组不能满

（2）插入元素的位置要求：不能再第一个元素之前插入，也不可以在数组现有元素的个数，之后之后插入；比如，数组中有3个元素，可以在第3个元素之前插入，也可以在第3个元素位置后面插入（这是写程序人自己规定的）。

比如，我们要在元素56前面加入21，我们要做的就是把数组56,23,56,12,5依次往后移一位，但是我们必须从元素5开始往后移，这样数据才不会覆盖；需要一个循环来完成，循环变量i的初始值应该5的位置，所以i=cnt-1，循环条件：应该是i移到56的位置，此时i=pos-1；

对于一些操作，我们可以用特殊值来试凑，来循环循环变量的初始值，和循环结束条件；

4.删除一个元素

[cpp]  view plain  copy
  1. /********************************************************************************* 
  2.   *Function: Delete_arr； 
  3.   *Description： 删除数组的第pos个元素 
  4.   *Calls:  IsFull_arr()； 
  5.   *Called By: none； 
  6.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  7.            参数——pos，数组的第pos个元素将被删除 
  8.            参数——val，返回要删除的数据； 
  9.   *Output:  把删除的数据，返回给指针val 
  10.   *Return:  布尔量，1表示删除成功；0，删除失败； 
  11.   *Others:  none 
  12. **********************************************************************************/  
  13. bool Delete_arr(struct Array *pArr,int pos,int *val)  
  14. {  
  15.     int i;  
  16.     if(IsEmpty_arr(pArr))  
  17.         return false;  
  18.     if(pos>pArr->cnt||pos<1)  
  19.         return false;  
  20.       
  21.     *val=pArr->pBase[pos-1];  
  22.     for(i=pos;i<=pArr->cnt-1;i++)  
  23.         pArr->pBase[i-1]=pArr->pBase[i];  
  24.         pArr->cnt--;  
  25.     return true;  
  26.   
  27. }  


     假设，要数组的第三个元素2，即pos=3；要做的动作就是把56,23,56,12,5依次往前移。循环变量的初始位置为第一个56所在的位置，即i=pos。循环结束条件是i<=cnt-1，此时才把需要移的元素移完。



5.选择排序

[cpp]  view plain  copy
  1. /********************************************************************************* 
  2.   *Function: SelectSort_arr； 
  3.   *Description： 用选择排序算法对数组中元素进行排序 
  4.   *Calls:  none； 
  5.   *Called By: none； 
  6.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  7.   *Output:  把删除的数据，返回给指针val； 
  8.   *Return:  void 
  9.   *Others:  none 
  10. **********************************************************************************/  
  11. void SelectSort_arr(struct Array *pArr)  
  12. {  
  13.     int i,j,temp;  
  14.     for(i=0;i<pArr->cnt-1;i++)  
  15.     {  
  16.         for(j=i+1;j<pArr->cnt;j++)  
  17.         if(pArr->pBase[i]>pArr->pBase[j])  
  18.         {  
  19.             temp=pArr->pBase[i];  
  20.             pArr->pBase[i]=pArr->pBase[j];  
  21.             pArr->pBase[j]=temp;  
  22.         }  
  23.     }  
  24. }  

直接选择排序的基本思想
   　 n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
 ①初始状态：无序区为R[1..n]，有序区为空。
 ②第1趟排序
    　在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
　　……
 ③第i趟排序
　　第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
    　这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

6.冒泡排序

[cpp]  view plain  copy
  1. /********************************************************************************* 
  2.   *Function: BubbleSort_arr； 
  3.   *Description： 利用冒泡排序对数组中的元素进行排序 
  4.   *Calls:  IsFull_arr()； 
  5.   *Called By: none； 
  6.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  7.   *Output:  none 
  8.   *Return: none； 
  9.   *Others:  none 
  10. **********************************************************************************/  
  11. void BubbleSort_arr(struct Array *pArr)  
  12. {  
  13.     int i,j,temp;  
  14.     bool exchange=false;  
  15.     for(i=0;i<pArr->cnt-1;i++)  
  16.     {  
  17.         exchange=false;  //开始前排序标志为false，代表没有交换；  
  18.         for(j=pArr->cnt-1;j>i;j--)  
  19.         {  
  20.             if(pArr->pBase[j]<pArr->pBase[j-1])  
  21.             {  
  22.                 temp=pArr->pBase[j];  
  23.                 pArr->pBase[j]=pArr->pBase[j-1];  
  24.                 pArr->pBase[j-1]=temp;  
  25.                 exchange=true;  
  26.             }  
  27.         }  
  28.         if(!exchange)  
  29.             return ;   //若一趟排序下来，数据没有交换说明，数据中的数据是有序的，就没有必要在进行循环了；     
  30.     }  
  31. }  

冒泡排序：排序方法

    　将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
（1）初始
　    R[1..n]为无序区。

（2）第一趟扫描
　    从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。
    　第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

（3）第二趟扫描
　    扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……
    　最后，经过n-1 趟扫描可得到有序区R[1..n]
  注意：
　    第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。

附件：程序源码

[cpp]  view plain  copy
  1. #include<stdio.h>  
  2. #include<stdlib.h>   //包含了exit函数  
  3. #include"malloc.h"  
  4. //定义一个新的数据类型,并没有分配内存空间  
  5. struct Array  
  6. {  
  7.    int *pBase; //定义一个指向数组的指针  
  8.    int len;    //数组中能够存放的最大元素个数  
  9.    int cnt;    //当前数组中元素的个数  
  10. };  
  11.   
  12. void Init_arr(struct Array *pArr,int len);//初始化数组  
  13. bool append_arr(struct Array *pArr,int val);//在数组后追加一个元素  
  14. bool Insert_arr(struct Array *pArr,int pos,int val);//指定位置插入元素  
  15. bool Delete_arr(struct Array *pArr,int pos,int *val);//指定位置删除元素  
  16.   
  17. bool IsFull_arr(struct Array *pArr);//判断数组是否满  
  18. bool IsEmpty_arr(struct Array *pArr);//判断数组是否空  
  19.   
  20. void show_arr(struct Array *pArr);//打印数组中的元素  
  21. void Inversion_arr(struct Array *pArr);//倒置数组中的元素  
  22. void SelectSort_arr(struct Array *pArr);//选择排序  
  23. void BubbleSort_arr(struct Array *pArr);//冒泡排序  
  24. int main()  
  25. {  
  26.     struct Array arr;   //定义一个结构体变量，并分配内存在静态区；（静态区、堆，栈）  
  27.     printf("字节数： %d",sizeof(struct Array));  
  28.     //struct Array *pArr; //定义一个结构体指针，并为此指针分配了4字节的内存  
  29.     //pArr=(struct Array *)malloc(sizeof(struct Array)); //此时只是为pBsae指针，len,cnt变量分配了内存；  
  30.     //arr.pBase=(int *)malloc(sizeof(int)*arr.len);  
  31.     Init_arr(&arr,8);  
  32.     show_arr(&arr);  
  33.     append_arr(&arr,2);  
  34.     append_arr(&arr,5);  
  35.     append_arr(&arr,54);  
  36.     append_arr(&arr,54);  
  37.     append_arr(&arr,89);  
  38.     if(!append_arr(&arr,18))  
  39.     printf("追加失败\n");  
  40.   
  41.     if(!Insert_arr(&arr,3,99))  
  42.         printf("插入失败\n");  
  43.   
  44.     show_arr(&arr);  
  45.     int DelElement=0;  
  46.     int *p=&DelElement;  
  47.     Delete_arr(&arr,2,p);  
  48.     printf("删除的元素是:%d\n",*p);  
  49.     show_arr(&arr);  
  50.   
  51.     SelectSort_arr(&arr);  
  52.     printf("选择排序后\n");  
  53.     show_arr(&arr);  
  54.   
  55.     //show_arr(&arr);  
  56.     /*Inversion_arr(&arr); 
  57.     printf("倒置后\n"); 
  58.     show_arr(&arr); 
  59.  
  60.     BubbleSort_arr(&arr); 
  61.     printf("冒泡排序后\n"); 
  62.     show_arr(&arr); 
  63.     */  
  64.     return 0;  
  65. }  
  66. /********************************************************************************* 
  67.   *Function: Init_arr； 
  68.   *Description： 创建并初始化一个数组； 
  69.   *Calls:  malloc()、printf()、exit()； 
  70.   *Called By:  none 
  71.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  72.            参数——len是说明创建的数组的容量，也就是能装元素的最大个数； 
  73.           //输入参数的说明，包括每个参数的作用、取值说明及参数间关系； 
  74.   *Output:  none 
  75.   *Return:  none 
  76.   *Others:  none 
  77. **********************************************************************************/  
  78. void Init_arr(struct Array *pArr,int len)  
  79. {  
  80.       
  81.     pArr->pBase=(int *)malloc(sizeof(int)*pArr->len);  
  82.     if(NULL==pArr->pBase)  
  83.     {  
  84.         printf("分配内存失败");  
  85.         exit(-1);   //终止程序  
  86.           
  87.     }  
  88.     else  
  89.     {  
  90.        pArr->cnt=0;  
  91.        pArr->len=len;  
  92.     }  
  93.         return;  //加return的目的是为了告诉其他人，此函数到此已经写完了  
  94. }  
  95. /********************************************************************************* 
  96.   *Function: show_arr； 
  97.   *Description： 打印出数组中所有元素； 
  98.   *Calls:  printf()； 
  99.   *Called By:  none 
  100.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  101.   *Output:  none 
  102.   *Return:  none 
  103.   *Others:  none 
  104. **********************************************************************************/  
  105. void show_arr(struct Array *pArr)  
  106. {  
  107.     int i;  
  108.     printf("数组的最大元素个数：%d\n",pArr->len);  
  109.     printf("数组的当前元素个数：%d\n",pArr->cnt);  
  110.     for(i=0;i<pArr->cnt;i++)   //只要显示数组中有的元素  
  111.         printf("%d ",pArr->pBase[i]);  
  112.     printf("\n");  
  113. }  
  114. /********************************************************************************* 
  115.   *Function: append_arr； 
  116.   *Description： 在数组最后一个元素后面添加一个元素； 
  117.   *Calls:  IsFull_arr()； 
  118.   *Called By:  none 
  119.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  120.            参数——val，要添加的数据； 
  121.           //输入参数的说明，包括每个参数的作用、取值说明及参数间关系； 
  122.   *Output:  none 
  123.   *Return:  布尔量，1表示追加成功；0，追加失败； 
  124.   *Others:  none 
  125. **********************************************************************************/  
  126. bool append_arr(struct Array *pArr,int val)    
  127. {  
  128.     if(!IsFull_arr(pArr))  
  129.     {  
  130.         pArr->pBase[pArr->cnt++]=val;  
  131.         return true;  
  132.     }  
  133.     else  
  134.     return false;  
  135. }  
  136. /********************************************************************************* 
  137.   *Function: IsFull_arr； 
  138.   *Description： 判断数组是否满； 
  139.   *Calls:  none； 
  140.   *Called By:  append_arr()，Insert_arr()； 
  141.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  142.   *Output:  none 
  143.   *Return:  布尔量，1表示数组满；0，数组不满； 
  144.   *Others:  none 
  145. **********************************************************************************/  
  146. bool IsFull_arr(struct Array *pArr)  //true 与 false 一般用于返回bool类型的函数  
  147. {  
  148.     if(pArr->cnt==pArr->len)  
  149.     {    
  150.        return true;  
  151.     }  
  152.     else  
  153.        return false;  
  154. }  
  155. /********************************************************************************* 
  156.   *Function: Insert_arr； 
  157.   *Description： 在数组的第pos个元素前，插入val元素；； 
  158.   *Calls:  IsFull_arr()； 
  159.   *Called By: none； 
  160.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  161.            参数——pos，表示位置，在数组第pos元素前加入数据val； 
  162.            参数——val，表示要插入的数据； 
  163.   *Output:  none 
  164.   *Return:  布尔量，1表示插入成功；0，插入失败； 
  165.   *Others:  none 
  166. **********************************************************************************/  
  167. bool Insert_arr(struct Array *pArr,int pos,int val)  
  168. {  
  169.     int i;  
  170.     if(IsFull_arr(pArr))          //为空不能进行插入操作  
  171.         return false;  
  172.     if(pos<1||pos>pArr->cnt+1)  //插入的位置不能在第一个元素前面，也不可以在最后一个元素后面的后面插入  
  173.         return false;  
  174.       
  175.         for(i=pArr->cnt-1;i>=(pos-1);i--)  
  176.             pArr->pBase[i+1]=pArr->pBase[i];  
  177.         pArr->pBase[pos-1]=val;  
  178.         pArr->cnt++;  
  179.         return true;  
  180.   
  181. }  
  182. /********************************************************************************* 
  183.   *Function: IsEmpty_arr； 
  184.   *Description： 判断数组是否空； 
  185.   *Calls:  none； 
  186.   *Called By:  Delete_arr()； 
  187.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  188.   *Output:  none 
  189.   *Return:  布尔量，1表示数组空；0，数组不空； 
  190.   *Others:  none 
  191. **********************************************************************************/  
  192. bool IsEmpty_arr(struct Array *pArr)  
  193. {  
  194.     if(0==pArr->cnt)  
  195.         return true;  
  196.     else  
  197.         return false;  
  198. }  
  199. /********************************************************************************* 
  200.   *Function: Delete_arr； 
  201.   *Description： 删除数组的第pos个元素 
  202.   *Calls:  IsFull_arr()； 
  203.   *Called By: none； 
  204.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  205.            参数——pos，数组的第pos个元素将被删除 
  206.            参数——val，返回要删除的数据； 
  207.   *Output:  把删除的数据，返回给指针val 
  208.   *Return:  布尔量，1表示删除成功；0，删除失败； 
  209.   *Others:  none 
  210. **********************************************************************************/  
  211. bool Delete_arr(struct Array *pArr,int pos,int *val)  
  212. {  
  213.     int i;  
  214.     if(IsEmpty_arr(pArr))  
  215.         return false;  
  216.     if(pos>pArr->cnt||pos<1)  
  217.         return false;  
  218.       
  219.     *val=pArr->pBase[pos-1];  
  220.     for(i=pos;i<=pArr->cnt-1;i++)  
  221.         pArr->pBase[i-1]=pArr->pBase[i];  
  222.         pArr->cnt--;  
  223.     return true;  
  224.   
  225. }  
  226. /********************************************************************************* 
  227.   *Function: Inversion_arr； 
  228.   *Description： 倒置数组中的元素 
  229.   *Calls:  none； 
  230.   *Called By: none； 
  231.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  232.   *Output:  none 
  233.   *Return:  none 
  234.   *Others:  none 
  235. **********************************************************************************/  
  236. void Inversion_arr(struct Array *pArr)  
  237. {  
  238.       
  239.     int i,j,temp;  
  240.     for(i=0,j=pArr->cnt-1;i<j;i++,j--)  //i,j分别指向数组的首尾元素，没移动一次交换一次，直到不满足条件i<j;  
  241.     {  
  242.         temp=pArr->pBase[i];  
  243.         pArr->pBase[i]=pArr->pBase[j];  
  244.         pArr->pBase[j]=temp;  
  245.       
  246.   
  247.     }  
  248. }  
  249. /********************************************************************************* 
  250.   *Function: SelectSort_arr； 
  251.   *Description： 用选择排序算法对数组中元素进行排序 
  252.   *Calls:  none； 
  253.   *Called By: none； 
  254.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  255.   *Output:  把删除的数据，返回给指针val； 
  256.   *Return:  void 
  257.   *Others:  none 
  258. **********************************************************************************/  
  259. void SelectSort_arr(struct Array *pArr)  
  260. {  
  261.     int i,j,temp;  
  262.     for(i=0;i<pArr->cnt-1;i++)  
  263.     {  
  264.         for(j=i+1;j<pArr->cnt;j++)  
  265.         if(pArr->pBase[i]>pArr->pBase[j])  
  266.         {  
  267.             temp=pArr->pBase[i];  
  268.             pArr->pBase[i]=pArr->pBase[j];  
  269.             pArr->pBase[j]=temp;  
  270.         }  
  271.     }  
  272. }  
  273. /********************************************************************************* 
  274.   *Function: BubbleSort_arr； 
  275.   *Description： 利用冒泡排序对数组中的元素进行排序 
  276.   *Calls:  IsFull_arr()； 
  277.   *Called By: none； 
  278.   *Input:  参数一pArr是一个结构体指针变量，用来接受结构体变量的地址的； 
  279.   *Output:  none 
  280.   *Return: none； 
  281.   *Others:  none 
  282. **********************************************************************************/  
  283. void BubbleSort_arr(struct Array *pArr)  
  284. {  
  285.     int i,j,temp;  
  286.     bool exchange=false;  
  287.     for(i=0;i<pArr->cnt-1;i++)  
  288.     {  
  289.         exchange=false;  //开始前排序标志为false，代表没有交换；  
  290.         for(j=pArr->cnt-1;j>i;j--)  
  291.         {  
  292.             if(pArr->pBase[j]<pArr->pBase[j-1])  
  293.             {  
  294.                 temp=pArr->pBase[j];  
  295.                 pArr->pBase[j]=pArr->pBase[j-1];  
  296.                 pArr->pBase[j-1]=temp;  
  297.                 exchange=true;  
  298.             }  
  299.         }  
  300.         if(!exchange)  
  301.             return ;   //若一趟排序下来，数据没有交换说明，数据中的数据是有序的，就没有必要在进行循环了；     
  302.     }  
  303. }  
玛丽奥ZJY
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之数组及其操作（C语言版）
yanyuzuixin的博客
10-12 1210
一.数组结构体定义 #define ARRAY_SIZE 50   typedef struct {     int data[ARRAY_SIZE];     int len; }MyArray; 其中， ARRAY_SIZE表示数组的最大长度 len表示数组的当前长度，其实也可以表示为数组最后一个元素的下标（last），没有多大区别，凭个人喜好。 二. 初始化操
数据结构（C语言）-数组
czh2637750821的博客
02-21 3279
数组一、数组的抽象数据类型定义二、数组的顺序存储三、特殊矩阵的压缩存储1、对称矩阵2、三角矩阵3、对角矩阵4、稀疏矩阵 学习视频 数组：按一定格式排列起来的具有相同类型的数据元素的集合 一维数组：若线性表中的数据元素为非结构的简单元素则称为一维数组。 一维数组的逻辑结构：线性结构。定长的线性表 格式：数据类型 变量名称[长度] 二维数组：若一维数组中的数据元素又是一维数组结构，则称为二维数组 二维数组的逻辑结构分为： 非线性结构：每一个数据元素即在一个行表中又在一个 列表中。 线性结构：改线性表的每个数据
C语言数据结构——数组
JianZha
04-09 202
#include<stdio.h> #include<stdlib.h> #include<malloc.h> struct Array { int * pBase; // 存储的是数组第一个元素的地址 int len; // 数组所能容纳的最大元素的个数 int cnt; // 当前数组有效元素的个数 }; typedef struct Array Arr; void init_arr(Arr *pArr, int length
【C语言数据结构】数组
热门推荐
布小禅的博客
10-21 1万+
【数据结构C语言实现】
数据结构与算法：C语言描述.zip
最新发布
06-17
这份名为“数据结构与算法：C语言描述.zip”的压缩包文件，显然是为了帮助大学生深入理解数据结构并掌握用C语言实现算法的方法。 首先，我们要了解什么是数据结构。数据结构是组织、存储和管理数据的方式，它决定了...
数据结构：数组PPT学习教案.pptx
10-08
数据结构中的数组是一种基础且重要的概念，它是一种特殊的线性表，其中的每个元素本身也是一个线性表。数组的特殊之处在于，它具有固定的大小和特定的索引系统，允许快速访问任何位置的元素。多维数组是数组的扩展，...
数组数据结构实现c语言
wu2369795821的博客
01-14 90
写数组结构遇到的一些小问题
数据结构之数组（C语言实现）
kang___xi的博客
08-29 6191
数组是大家很熟悉的一种数据类型，而且在我们的程序设计中也应用非常广泛。这里以抽象数据类型的形式讨论数组的定义和实现。一、数组的定义假设n维数组中含有第i维的长度为b(i)，则数组的总长度为b(0) *b(1)*...*b(n-1)，每个元素都受着n个关系的约束。在每个关系中元素a(j1,j2,...,jn) (0<=jn<=b(i)-2)都有一个直接后继元素。因此，就单个关系而言，这n个关系仍然是线
数据结构-数组详解（类C语言版）
秃了也弱了
05-09 3874
目录 数组的概念 一维数组 一维数组的逻辑结构 声明格式 二维数组 二维数组的逻辑结构 声明格式 三维数组 结论 数组特点 数组的抽象数据类型定义 数组的顺序存储 二维数组的行序优先表示 三维数组的元素存储位置 n维数组的元素存储位置 例如 特殊矩阵的压缩存储 概念 什么是压缩存储 什么样的矩阵能够压缩 什么叫稀疏矩阵 对称矩阵 特点 存储方法 对称矩阵的存储结构 数组的概念 按一定格式排列起来的，具有相同类型的数据元素的集合。 一维数...
数据结构C语言版_数组的顺序存储表示
08-19
数据结构C语言版_数组的顺序存储表示和实现 不解释 是好东西
【数据结构与算法——C语言版】2. 数组
CSDNGuoYuying的博客
01-05 415
介绍了数组的基础定义及使用，并针对数组的基本增删改查做了一些代码示例，下篇文章将讲解基于数组的更高效的方法，比如二分查找、插入排序等。
[郝斌]数据结构C语言—数组
myyangchh的博客
01-07 1040
郝斌数据结构学习，数组二次封装函数接口实现。
【数据结构】用C语言实现对数组的操作
hellobupt_an的博客
08-24 3090
今天开始复习数据结构了，先从对数组的操作开始。 #include &lt;stdio.h&gt; #include &lt;sys/malloc.h&gt; #include &lt;stdbool.h&gt; struct Arr //定义数组的数据结构 { int * pBase; int lenth; int cnt; }; void init(struct...
数据结构入门——数组篇（c语言实现数组，附源码）
qq_41910976的博客
08-01 2478
一、数组的定义 数组是多个有序数据的集合（有序：地址连续），数组中的每一个元素都属于同一数据类型。 二、数组的声明 一维数组 一维数组声明的简单形式： 类型说明符 数组名 [整数类型表达式]; 其中，类型说明符是数组元素的类型，数组名是一个标识符，符号“[]”内的整数类型表达式表示数组元素的个数，即数组的长度。如果整数类型表达式是常量表达式，其值必须大于0。 二维数组 二维数组声明的简单形式： ** 类型说明符 数组名 【行数 】【列数 】; ** 其中，类型说明符是数组元素的类型，数组名是一个标识符；行数
数据结构-顺序表的基本操作（c语言）
qq_39871579的博客
07-05 649
数据结构中顺序表的增删改查基本操作： 代码如下： #include <stdio.h> #include <stdlib.h> typedef struct Table{ int * head; int length; int size; }table; //初始化 void initTable(table *t,int size){ (*t).head=(int*)ma
c语言中数组实用的三个步骤,数据结构之数组及其操作（C语言版）
weixin_39854951的博客
05-19 466
一.数组结构体定义#define ARRAY_SIZE 50typedef struct{int data[ARRAY_SIZE];int len;}MyArray;其中，ARRAY_SIZE表示数组的最大长度len表示数组的当前长度，其实也可以表示为数组最后一个元素的下标(last)，没有多大区别，凭个人喜好。二. 初始化操作void ArrayInit(MyArray *arr){int i;...
数据结构学习之路（一）C语言对数组的简单实现
zyy_2018的博客
03-28 1073
以下的程序只是在观看郝斌老师讲解的(C语言数据结构)之后自己做得简单练习。传送门：郝斌-数据结构# include &lt;stdio.h&gt; # include &lt;stdlib.h&gt; typedef struct MyArray{ int * pBase; //存放数组第一个元素的地址 int len; //数组长度 int cnt; //数组的有效长度 }* PAR...
数据结构：超基础！超详细！超简单！——C语言数组实现顺序栈的创建及基本操作的使用
qq_44131760的博客
05-10 716
前言 之前我不懂的时候，我看其他大佬写的代码简直一头雾水啊，各种复杂操作。。。现在我写了一个超简洁版的，目的是主要体现顺序栈原理，希望对读者有帮助。 简述原理 这段代码是顺序栈的实现。顺序栈的最大特点是长度不变，预先分配好一段存储单元，存储的数据物理上连续。关于栈的构建是用数组来实现的。而入栈出栈操作用会“能上下移动”的top元素来指定数组的特定存储单元。比如说，top=1.，那stack[top]指示的就是stack[1]，如果top=3，那就是数组的第3个元素辣。至于怎么保持top的数字永远指的是最顶端
C语言编程：数组与结构解析
一维数组是C语言中基本的数据结构之一，它允许我们存储相同类型的一组数据。在描述的示例中，为了存储10个同学的外语成绩，我们可以使用一维数组而不是单独定义10个变量。数组的主要特点是所有元素具有相同的类型，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值