devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

八大排序算法(C语言)_非比较排序c语言

作者：知新_RL | 2024-03-21 03:17:49

赞

踩

非比较排序c语言

目录

一.插入排序

1.1直接插入排序

1.2希尔排序

二.选择排序

2.1选择排序

2.2堆排序

三.交换排序

3.1冒泡排序

3.2快速排序

四.归并排序

4.1归并排序

五.非比较排序

5.1计数排序

一.插入排序

基本思想:(默认升序)从数组中的第二个元素开始,先使用一个变量保存这个元素的下标,开然后始跟前一个比较,如果比他小则交换位置继续跟前一个比较,直到找到一个位置比它的前一个元素大则停止(或走到数组开头也停止),然后保存的下标后移继续之前的操作,直到数组末尾.

1.1直接插入排序

基本思想:直接插入排序则是对插入排序思想的直接实现.

时间复杂度:O(N^2)

空间复杂度:O(1)

稳定性:稳定

适用情况:数组越接近有序使用直接插入排序效率越高.

运行图解:

代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void InsertSort(int* a,int n){//算法实现
  5.   int i,insert,temp;
  6.   for(i=1;i<n;i++){//从第二个元素开始向前比较
  7.     insert=i-1;//元素要插入的位置
  8.     temp=a[i];//记录当前元素的数值
  9. //开始向前比较,插入位置没到数组头部或insert位置的元素大于要插入元素,一直循环.
  10.     while(insert>=0 && temp<a[insert]){
  11.       a[insert+1]=a[insert];//比插入元素大的直接后移
  12.       insert--;//insert向前
  13.     }
  14.     a[insert+1]=temp;//找到比要插入元素小的元素的位置,直接放到其后面.
  15.   }
  16. }
  17.  
  18. void PrintList(int* a,int n){//打印数组
  19.   int i;
  20.   for(i=0;i<n;i++){
  21.     printf("%d",a[i]);
  22.   }
  23.   printf("\n");
  24. }
  25.  
  26. int main(){//测试
  27.   int a[]={3,1,6,2,7,9,8,5,4};
  28.   InsertSort(a,sizeof(a)/sizeof(a[0]));
  29.   PrintList(a,sizeof(a)/sizeof(a[0]));
  30.   return 0;
  31. }

1.2希尔排序

基本思想:对直接插入排序的优化,因为上面我们知道了,直接插入排序在数组接近有序的情况下排序效率越高,所以我们就想办法让数组接近有序,因此我们可以给个间隔,让所有以间隔为一组的数据全部进行直接插入排序,间隔缩小继续进行上面的操作,当间隔为1的时候这时数组已经是接近有序的数组,再次使用直接插入排序效率就会有明显提高.

时间复杂度:O(N^1.25)~O(1.6*N^1.25)之间

空间复杂度:O(1)

稳定性:不稳定

gap(间隔):我们这里的取间隔方式有很多种我在代码中采用gap=n/2,n为数组长度,使gap每次缩小一半直到为1.

适用情况:数组越接近有序效率越高.

运行图解:

 代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void ShellSort(int* a,int n){//算法实现
  5.   int i,gap=n/2;
  6.   while(gap>0){//使用gap让数组逐渐接近有序
  7.     i=0;
  8.     //类似直接插入排序(将直接插入排序中的1换为gap)
  9.     while(i+gap<n){
  10.       int insert=i;//元素插入位置
  11.       int temp=a[i+gap];//记录要插入元素的值
  12. //开始向前比较,插入位置没到数组头部或insert位置的元素大于要插入元素,一直循环.
  13.       while(insert>=0 && temp<a[insert]){
  14.         a[insert+gap]=a[insert];//插入位置元素大于要插入的元素,插入位置的元素后移
  15.         insert=insert-gap;//插入位置前移
  16.       }
  17.      a[insert+gap]=temp;//插入
  18.      i++;
  19.     }
  20.     gap=gap/2;//间隔每次缩小一半
  21.   }
  22. }
  23.  
  24. void PrintArray(int* a,int n){//打印数组
  25.   int i;
  26.   for(i=0;i<n;i++){
  27.     printf("%d",a[i]);
  28.   }
  29.   printf("\n");
  30. }
  31.  
  32. int main(){//测试
  33.   int a[]={3,4,2,6,5,9,8,7,1};
  34.   ShellSort(a,sizeof(a)/sizeof(a[0]));
  35.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  36.   return 0;
  37. }

二.选择排序

基本思想:(默认升序),从数组所有元素中找出最大的元素放在数组尾,然后再找出第二大的元素放在数组倒数第二的位置,依次类推当进行到最后一个元素时数组刚好是呈升序的有序数组.

2.1选择排序(优化)

基本思想:既然我们每次遍历数组都是找到最大的元素放在数组尾,那么我们可以对该算法进行优化,每次遍历数组不仅找到最大的值也找的最小的值,将最大的值放到数组尾,最小的值放到数组首,这样我们每遍历一次数组就排好了两个值,对比之前的算法提高了接近一倍的效率.

时间复杂度:O(N^2)

空间复杂度:O(1)

稳定性:不稳定

运行图解:

 代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void Swap(int* a,int* b){//交换数据
  5.   int temp=*b;
  6.   *b=*a;
  7.   *a=temp;
  8. }
  9.  
  10. /*
  11. void SelectSort(int* a,int n){//选择排序
  12.   int i,j,max;
  13.   for(i=0;i<n-1;i++){//查找n-1次(最后剩一个元素时不用比较)
  14.     max=0;
  15.     for(j=1;j<n-i;j++){//从第二个元素位置开始向n-i开始遍历寻找最大的值的下标
  16.       if(a[max]<a[j]){
  17.         max=j;
  18.       }
  19.     }
  20.     Swap(&a[max],&a[n-1-i]);//把最大的值与最后一个元素交换
  21.   }
  22. }
  23. */
  24.  
  25. void SelectSort1(int* a,int n){//选择排序优化(降序)
  26.   int i,j,max,min,sum=0;
  27.   for(i=0;i<n-1;i=i+2){//每次排好两个元素进行循环
  28.     max=sum;
  29.     min=sum;
  30.     for(j=sum+1;j<n-sum;j++){//从sum+1到n-sum的遍历,查找最大元素下标和最小元素下标
  31.       if(a[max]<a[j]){
  32.         max=j;
  33.       }
  34.       if(a[min]>a[j]){
  35.         min=j;
  36.       }
  37.     }
  38.     Swap(&a[max],&a[sum]);//把最大的元素放到第一位
  39.     if(sum==min){//防止最小的元素本身就在第一位.
  40.       Swap(&a[max],&a[n-1-sum]);
  41.     }else{
  42.       Swap(&a[min],&a[n-1-sum]);
  43.     }
  44.     sum++;
  45.   }
  46. }
  47.  
  48. void PrintArray(int* a,int n){//打印数组
  49.   int i;
  50.   for(i=0;i<n;i++){
  51.     printf("%d ",a[i]);
  52.   }
  53.   printf("\n");
  54. }
  55.  
  56. int main(){//测试
  57.   int a[]={3,6,5,2,9,6,8,7,1};
  58.   SelectSort1(a,sizeof(a)/sizeof(a[0]));
  59.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  60.   return 0;
  61. }

2.2堆排序

基本思想:首先我们要了解什么是堆,堆分为大根堆和小根堆,小根堆的双亲结点永远小于其子节点,因此我们可以将数据进行堆调整化成堆,此时的根节点就是最小的元素,我们将此节点从堆中删除,(堆的删除方法就是把根节点与最后一个节点交换,堆的长度减一,然后重新进行堆调整),因此我们一直对堆进行删除操作,当堆中只有一个元素时停止,此时数组正好成降序.使用大根堆则刚好相反.

时间复杂度:O(N*logN)

空间复杂度:O(1)

稳定性:不稳定

运行图解:

代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void Swap(int* a,int* b){//交换数据
  5.   int temp=*b;
  6.   *b=*a;
  7.   *a=temp;
  8. }
  9.  
  10. void AdjustDwon(int* a,int n,int root){//向下调整(堆调整)建立大根堆
  11.   int parents=root;//双亲结点位置
  12.   int child=root*2+1;//孩子结点位置
  13.   while(child<n){//孩子结点位置不能大于数组长度
  14.     if(child+1<n && a[child]<a[child+1]){//在右孩子存在的情况下,让child处在更大的位置
  15.       child++;
  16.     }
  17.     if(a[parents]<a[child]){//如果双亲结点小于孩子结点就进行交换
  18.       Swap(&a[parents],&a[child]);
  19.       parents=child;//交换之后重新设置双亲结点的位置和孩子结点的位置继续进行判断
  20.       child=parents*2+1;
  21.     }else{
  22. //如果双亲结点大于孩子结点就直接退出函数(要进行向下调整的条件就是该节点的左右子树已经是堆了)
  23.       return;
  24.     }
  25.   }
  26. }
  27.  
  28. void HeapSort(int* a,int n){//堆排序
  29.   int i,j;
  30.   for(i=(n-2)/2;i>=0;i--){//从最后一个双亲结点开始调用向下调整建立堆
  31.     AdjustDwon(a,n,i);
  32.   }
  33.   for(j=n-1;j>0;j--){//使用堆删除进行堆排序
  34.     Swap(&a[0],&a[j]);//将首尾结点数据交换
  35.     AdjustDwon(a,j,0);//将堆的长度减一,从根开始进行向下调整,重新建立堆
  36.   }
  37. }
  38.  
  39. void PrintArray(int* a,int n){//打印数组
  40.   int i;
  41.   for(i=0;i<n;i++){
  42.     printf("%d ",a[i]);
  43.   }
  44.   printf("\n");
  45. }
  46.  
  47. int main(){//测试
  48.   int a[]={4,5,2,3,8,9,6,7,1};
  49.   HeapSort(a,sizeof(a)/sizeof(a[0]));
  50.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  51.   return 0;
  52. }

三.交换排序

基本思想:所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

3.1冒泡排序

基本思想:(默认升序)令i=0,从第i个元素开始和其相邻的i+1元素数值进行比较,如果i的数值大就进行交换,反之则不用交换,然后i+1,再重复上述操作,直到i走到n-1的位置.这样就将最大的元素放在了最后一位,然后重复上面的操作,已经排序好的则不用再比较,直到数组只剩下一个元素时停止此时数组是成升序的有序数组.

时间复杂度:O(N^2)

空间复杂度:O(1)

稳定性:稳定

运行图解:

代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void Swap(int* a,int* b){//交换数据
  5.   int temp=*b;
  6.   *b=*a;
  7.   *a=temp;
  8. }
  9.  
  10. void BubbleSort(int* a,int n){//冒泡排序
  11.   int i,j,length=n-1;
  12.   for (i=0;i<length;i++){//n个元素总共排序n-1个元素
  13.     int flag=0;
  14. //标志位用来标识一趟循环中是否有数据的交换,如果没有数据的交换说明数组已经为有序数组直接退出函 
  15. //数即可
  16.     for(j=0;j<length-i;j++){//进行一趟循环,每排序好一个元素此循环少进行一次
  17.       if(a[j] < a[j+1]){//(降序)第j个元素与第j+1个元素比较如果比其小就进行交换,并将flag变1
  18.         Swap(&a[j],&a[j+1]);
  19.         flag=1;
  20.       }
  21.     }
  22.     if(0==flag){//没有进行数据交换则说明数组有序,直接退出函数
  23.       break;
  24.     }
  25.   }
  26. }
  27.  
  28. void PrintArray(int* a,int n){//打印数组
  29.   int i;
  30.   for(i=0;i<n;i++){
  31.     printf("%d ",a[i]);
  32.   }
  33.   printf("\n");
  34. }
  35.  
  36. int main(){//测试
  37.   int a[]={4,3,2,7,9,8,6,5,1};
  38.   BubbleSort(a,sizeof(a)/sizeof(a[0]));
  39.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  40.   return 0;
  41. }

3.2快速排序

基本思想:(默认升序)从数组中取一个数的来作为标准数,然后遍历数组,将比这个标准数大的放到其后面,比他小的放到其前面,此时这个标准数所在的位置就是他在有序数组中的位置,然后使用递归对其左右的数据也进行这种操作.直到左元素下标大于等于右元素下标时停止,此时数组是成升序的有序数组.

对快速排序的扩展和优化:

a.优化

三数取中:我们取标准数的时候,取的数越居中则算法的时间复杂度越低越接近O(N*logN)效率越高,我们取的数越极端越接近最大或最小值则时间复杂度越高越接近O(N^2)效率越低,因此我们使用三数取中法取得的标准数更居中,具体操作是从数组的首尾中三个位置取三个数,然后以这三个数中居中的数为标准数.

b.扩展(快排的三种方法)

hoare法:先选取标准数,然后定义两个指针(prev(前),rear(后)),一个从前向后走,一个从后向前走,使用prev找到比标准数大的数,使用rear找到比标准数小的数,然后交换两个数,直到prev和rear走到相同位置时退出循环,再将标准数跟此处进行交换即可.

挖坑法:先选取标准数,将标数放到数组尾部然后记录到temp中,然后定义prev(前),rear(后),prev先走找到比标准数大的直接放到数组尾部,然后rear继续走找到比标准数小的直接放到prev的位置,继续重复上面的操作,直到prev和rear走到一起退出循环,将temp中的数放到此处即可.

前后指针法:先选取标准数,将标准数放到数组首部,然后定义前后指针prev在首部,cur=prev+1,两个指针一起向后走,cur找比标准数小的,prev找比标准数大的,都找到后进行交换,当cur走到末尾时退出循环,因为prev所在的位置一直是小于标准数的数中最后一位,所以将标准数与prev所在的位置进行交换,将标准数放在中间即可.

特性:

时间复杂度:O(N*logN)

空间复杂度:O(logN)

稳定性:不稳定

适用情况:数组元素越无序越混乱,该排序效率越高.

运行图解:

hoare:

查看源图像

代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void Swap(int* a,int* b){
  5.   int temp=*b;
  6.   *b=*a;
  7.   *a=temp;
  8. }
  9.  
  10. //取中间数
  11. int MidNum(int* a,int b,int c,int d){
  12.   int n_1=a[b],n_2=a[c],n_3=a[d];
  13.   int temp[3]={n_1,n_2,n_3};
  14.   if(temp[0]>temp[1]){
  15.     Swap(&temp[0],&temp[1]);
  16.   }
  17.   if(temp[1]>temp[2]){
  18.     Swap(&temp[1],&temp[2]);
  19.   }
  20.   if(temp[0]>temp[1]){
  21.     Swap(&temp[0],&temp[1]);
  22.   }
  23.   if(temp[1]==a[b]){
  24.     return b;
  25.   }
  26.   if(temp[1]==a[c]){
  27.     return c;
  28.   }
  29.   return d;
  30. }
  31.  
  32. //hoare
  33. int PartSort1(int* a,int left,int right){//降序
  34.   int i=left,j=right,mid=MidNum(a,left,(left+right)/2,right);//三数取中
  35.   Swap(&a[right],&a[mid]);//将标准数放到末尾
  36.   int temp=a[right];//记录标准数
  37.   while(i<j){
  38.     while(i<j && a[i]>=temp){//找比标准数小的
  39.       i++;
  40.     }
  41.     while(i<j && a[j]<=temp){//找比标准数大的
  42.       j--;
  43.     }
  44.     Swap(&a[i],&a[j]);//交换
  45.   }
  46.   Swap(&a[i],&a[right]);//将标准数放到中间
  47.   return i;
  48. }
  49.  
  50. //挖坑法
  51. int PartSort2(int* a,int left,int right){
  52.   int i=left,j=right,mid=MidNum(a,left,(left+right)/2,right);//三数取中
  53.   Swap(&a[mid],&a[right]);//将标准数放到末尾
  54.   int temp=a[right];//记录标准数
  55.   while(i<j){
  56.     while(i<j && a[i]<=temp){//找比标准数大的数
  57.       i++;
  58.     }
  59.     if(i<j){//将其放到j的位置
  60.       a[j]=a[i];
  61.       j--;
  62.     }
  63.     while(i<j && a[j]>=temp){//找比标准数小的数
  64.       j--;
  65.     }
  66.     if(i<j){//将其放到i的位置
  67.       a[i]=a[j];
  68.       i++;
  69.     }
  70.   }
  71.   a[i]=temp;//将标准数的值放到中间
  72.   return i;
  73. }
  74.  
  75. //前后指针法
  76. int PartSort3(int* a,int left,int right){
  77.   int cur,prev,mid=MidNum(a,left,(left+right)/2,right);//三数取中
  78.   Swap(&a[left],&a[mid]);//将标准数放到首部
  79.   prev=left;//定义前后指针
  80.   cur=prev+1;
  81.   while(cur<=right){
  82.     if(a[cur]<a[left] && ++prev!=cur){//cur找比标准数小的,prev找比标准数大的然后交换
  83.       Swap(&a[cur],&a[prev]);
  84.     }
  85.     cur++;
  86.   }
  87.   Swap(&a[left],&a[prev]);//prev所在的位置永远在小于标准数的最后一位,将标准数与其交换放在中间
  88.   return prev;
  89. }
  90.  
  91. void QuickSort(int* a,int left,int right){//递归调用
  92.   if(left<right){//当left小于right时一直进行调用
  93.     int mid=PartSort3(a,left,right);//找到标准数所在的位置
  94.     QuickSort(a,left,mid-1);//对标准数的左侧进行调用
  95.     QuickSort(a,mid+1,right);//对标准数的右侧进行调用
  96.   }
  97. }
  98.  
  99. void PrintArray(int* a,int n){//打印数组
  100.   int i;
  101.   for(i=0;i<n;i++){
  102.     printf("%d ",a[i]);
  103.   }
  104.   printf("\n");
  105. }
  106.  
  107. int main(){测试
  108.   int a[]={3,4,2,7,5,6,9,8,1};
  109.   QuickSort(a,0,sizeof(a)/sizeof(a[0])-1);
  110.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  111.   return 0;
  112. }

四.归并排序

4.1归并排序

基本思想:(默认升序)先将数组中的元素使用递归进行分解当元素分解成单个数据的时候,采用合并有序数组的方式进行合并.(该算法的核心就是合并两个有序数组),定义三个指针分别指向两个有序数组的首部和一个新的数组的首部(定义一个新的数组用来存储排序好的数据),比较两个有序数组的指针的值将小的放到新的数组中小的这个指针后移,新数组的指针也后移,直到两个有序数组中有一个走到末尾结束循环,将没有走到末尾的那个有序数组中剩余的数据全部放到新数组的后面,此时新数组就是一个成升序的有序数组.

时间复杂度:O(N*logN)

空间复杂度:O(N)

稳定性:稳定

适用范围:归并排序的思考更多的是解决在磁盘中的外排序问题.

运行图解:

代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4.  
  5. //合并两个有序数组(降序)
  6. void MergeOrderArray(int* new_a,int* a,int begin_1,int end_1,int begin_2,int end_2){
  7.   int i=begin_1,j=begin_2,k=begin_1;//定义三个指针
  8.   while(i<=end_1 && j<=end_2){//对两个有序数组进行合并,当其中一个走到末尾时结束循环
  9.     if(a[i] >= a[j]){//比较两个有序数组中的元素,大的那个数放到新的数组中,同时两个指针后移
  10.       new_a[k++]=a[i++];
  11.     }else{
  12.       new_a[k++]=a[j++];
  13.     }
  14.   }
  15.   while(i<=end_1){//如果是以i遍历的数组没有走到末尾,则将其后面的元素全加到新数组的后面
  16.     new_a[k++]=a[i++];
  17.   }
  18.   while(j<=end_2){//如果是以j遍历的数组没有走到末尾,则将其后面的元素全加到新数组的后面
  19.     new_a[k++]=a[j++];
  20.   }
  21. }
  22.  
  23. void _MergeSort(int* new_a,int* a,int i,int j){//递归调用(类似于二叉树的后序遍历)
  24.   if(i<j){//对数组进行递归分解当i等于j时停止
  25.     int mid=i+((j-i)>>1);//找中间数值
  26.     _MergeSort(new_a,a,i,mid);//分解左边
  27.     _MergeSort(new_a,a,mid+1,j);//分解右边
  28.     MergeOrderArray(new_a,a,i,mid,mid+1,j);//调用合并算法对有序的数组进行合并
  29.     memcpy(a+i,new_a+i,sizeof(int)*(j-i+1));//将合并好的有序数组复制回原数组中
  30.   }
  31. }
  32.  
  33. void MergeSort(int* a,int n){//归并排序的外部调整
  34.   int* new_a=(int*)malloc(sizeof(int)*n);//创建新数组用来存储有序元素
  35.   if(NULL==new_a){
  36.     return;
  37.   }
  38.   _MergeSort(new_a,a,0,n-1);//递归调用
  39.   free(new_a);
  40. }
  41.  
  42. void PrintArray(int* a,int n){//打印数组
  43.   int i;
  44.   for(i=0;i<n;i++){
  45.     printf("%d ",a[i]);
  46.   }
  47.   printf("\n");
  48. }
  49.  
  50. int main(){//测试
  51.   int a[]={3,4,5,2,1,9,8,7,6};
  52.   MergeSort(a,sizeof(a)/sizeof(a[0]));
  53.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  54.   return 0;
  55. }

五.非比较排序

5.1计数排序

基本思想:(默认升序)从一组数据中找出最小和最大的元素,以其差值为界限创建新数组(初始化为0),然后以要排序数组中元素的值为新数组的下标,遍历要排序数组,每遍历到一个数据时在新数组中以该数据为下标的数组内容加一,及统计要排序数组中每个元素出现的次数,最后将这些次数按顺序填入要排序数组中,此时该数组是成升序的有序数组.

时间复杂度:O(max(N,max-min+1))

空间复杂度:O(max-min+1)

稳定性:稳定

使用情况:在元素特别集中时适用.

运行图解:

代码:(可直接复制测试)

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4.  
  5. void CountSort(int* a,int n){//计数排序(降序)
  6.   int max=a[0],min=a[0];
  7.   int i;
  8.   for(i=0;i<n;i++){//获取最大值和最小值
  9.     if(a[i]>max){
  10.       max=a[i];
  11.     }
  12.     if(a[i]<min){
  13.       min=a[i];
  14.     }
  15.   }
  16.   int length=max-min+1;
  17.   int* temp=(int*)calloc(length,sizeof(int));//以max-min+1为界限创建新数组
  18.   for(i=0;i<n;i++){//统计要排序数组中各个元素出现的次数
  19.     temp[a[i]-min]++;
  20.   }
  21.   int k=0;
  22.   for(i=length-1;i>=0;i--){//将统计好的数据依次按顺序填入要排序的数组
  23.     while(temp[i]!=0){
  24.       a[k++]=i+min;
  25.       temp[i]--;
  26.     }
  27.   }
  28.   free(temp);
  29. }
  30.  
  31. void PrintArray(int* a,int n){//打印数组
  32.   int i;
  33.   for(i=0;i<n;i++){
  34.     printf("%d ",a[i]);
  35.   }
  36.   printf("\n");
  37. }
  38.  
  39. int main(){//测试
  40.   int a[]={2,3,4,5,6,7,8,2,3,3,2,5,4,7,6,9,8,1};
  41.   CountSort(a,sizeof(a)/sizeof(a[0]));
  42.   PrintArray(a,sizeof(a)/sizeof(a[0]));
  43.   return 0;
  44. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/278003
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号