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

C语言7大常见排序（详细图解）

作者：Cpp五条 | 2024-06-01 15:09:37

赞

踩

C语言7大常见排序（详细图解）

目录

今日良言：总有不期而遇的温柔和生生不息的希望

一、排序介绍

二、插入排序

2.1直接插入排序

2.2希尔排序

三、选择排序

3.1选择排序

3.2堆排序

四、交换排序

4.1冒泡排序

4.2快速排序

五、归并排序 

       今日良言：总有不期而遇的温柔和生生不息的希望

一、排序介绍

1.1所谓排序就是对一组数据，按照某个关键字逐渐递增或者逐渐递减排列起来的操作。

如下图：按照价格高低对球鞋进行排序

 1.2常见的7大排序

二、插入排序

核心思路：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

2.1直接插入排序

我们平常打扑克牌就是典型的直接插入排序，如下图

 

 流程图解：

 代码：

  1. #include<stdio.h>
  2. void InsertSort(int* arr, int sz)//按照升序排序
  3. {
  4. 	int i = 0;
  5. 	for (i = 0; i < sz - 1; i++)//最多是将n-1的数据插入前面
  6. 	{
  7. 		int end = i;
  8. 		int tmp = arr[end + 1];//tmp存放的是end后面第一个数据即需要插入到前面的数据
  9. 		while (end >= 0)
  10. 		{
  11. 			//大于就将end的数据向后移动一位，小于就停止，说明此时end的位置已经为空，直接插入
  12. 			if (arr[end] > tmp)
  13. 			{
  14. 				arr[end + 1] = arr[end];
  15. 				end--;//继续让end前面的跟tmp中的数据比较
  16. 			}
  17. 			else
  18. 			{
  19. 				break;//说明此时tmp中的元素大于或者等于end的数据
  20. 			}
  21. 		}
  22. 		//直接将tmp即原来end-1位置的数据放入此时end+1的位置即可实现插入
  23. 		arr[end+1] = tmp;
  24. 	}
  25. }
  26. int main()
  27. {
  28. 	int arr[] = { 4,2,3,8,9,5,6,7,1,0 };
  29. 	int sz = sizeof(arr) / sizeof(int);
  30. 	InsertSort(arr, sz);
  31. 	int i = 0;
  32. 	for (i = 0; i < sz; i++)
  33. 	{
  34. 		printf("%d ", arr[i]);
  35. 	}
  36. 	return 0;
  37. }

 2.2希尔排序(缩小增量排序)

2.2.1核心思路：先选定一个整数（gap），把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后取重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

2.2.2  gap>1是预排序，gap=1就是直接插入排序

          gap越大，大的数会越快排到后面，小的数越快到前面

          gap越小，越接近有序

流程图解


 
代码

  1. #include<stdio.h>
  2. void ShellSort(int* arr, int sz)
  3. {
  4. 	int gap = sz;
  5. 	while (gap > 1)//当间隔大于1的时候进行预排序，等于1就是直接排序，此时已经有序
  6. 	{
  7. 		gap = gap / 2;//间隔越来越小
  8. 		int i = 0;
  9. 		for(i=0;i<sz-gap;i++)//把间隔为grap的多组数据同时排
  10. 		{
  11. 			int end = i;//要排序的位置的前grap个位置的元素
  12. 			int tmp = arr[end + gap];
  13. 			while (end >= 0)
  14. 			{
  15. 				if (arr[end] > tmp)//当end位置的数据大于tmp时，再与end-间隔（grap)的数据进行比较
  16. 				{
  17. 					arr[end + gap] = arr[end];//将比tmp大的数据依次向后移动间隔grap
  18. 					end -= gap;//每次让end减少间隔grap
  19. 				}
  20. 				else
  21. 				{
  22. 					break;
  23. 				}
  24. 			}
  25. 			//此时end下标的数据小于tmp。所以将tmp放入到end+grap的下标处
  26. 			arr[end + gap] = tmp;
  27. 		}
  28. 	}
  29. }
  30. int main()
  31. {
  32. 	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  33. 	int sz = sizeof(arr) / sizeof(int);
  34. 	ShellSort(arr, sz);
  35. 	int i = 0;
  36. 	for (i = 0; i < sz; i++)
  37. 	{
  38. 		printf("%d ", arr[i]);
  39. 	}
  40. 	return 0;
  41. }

三、选择排序

3.1选择排序

核心思路： 每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 .
为了提高效率,可以在一次遍历找到最大和最小元素的下标,然后分别和数组的起始位置和最后的位置进行交换.

流程图解

 代码：

  1. #include<stdio.h>
  2.  
  3. void Swap(int* p1, int* p2)
  4. {
  5. 	int tmp = *p1;
  6. 	*p1 = *p2;
  7. 	*p2 = tmp;
  8. }
  9. //直接选择排序
  10. void SelectSort(int* arr, int sz)
  11. {
  12. 	int begin = 0;
  13. 	int end = sz - 1;
  14. 	while (begin < end)
  15. 	{
  16. 		int mini = begin;//最小数的下标mini
  17. 		int maxi = begin;//最大数下标maxi
  18. 		int i = 0;
  19. 		for (i = begin; i <= end; i++)
  20. 		{
  21. 			if (arr[i] > arr[maxi])
  22. 			{
  23. 				maxi = i;
  24. 			}
  25. 			if (arr[i] < arr[mini])
  26. 			{
  27. 				mini = i;
  28. 			}
  29. 		}
  30. 		//下标为maxi的数据就是最大数，下标为mini的数据就是最小数
  31. 		Swap(&arr[begin], &arr[mini]);
  32. 		//如果begin和maxi重叠，需要重新修正一下maxi的位置，即交换后的mini的位置
  33. 		if (maxi == begin)
  34. 		{
  35. 			maxi = mini;
  36. 		}
  37. 		Swap(&arr[maxi],&arr[end]);
  38. 		end--;
  39. 		begin++;
  40. 	}
  41. }
  42. int main()
  43. {
  44. 	int arr[] = { 8,7,5,6,1,2,0,3,4,9 };
  45. 	int sz = sizeof(arr) / sizeof(arr[0]);
  46. 	SelectSort(arr, sz);
  47. 	int i = 0;
  48. 	for (i = 0; i < sz; i++)
  49. 	{
  50. 		printf("%d ", arr[i]);
  51. 	}
  52. 	return 0;
  53. }

3.2堆排序

3.2.1堆的逻辑结构是一颗完全二叉树，物理结构是一个数组。

3.2.2堆的两个特性：1.结构性：用数组表示的完全二叉树（逻辑结构）

                          2.有序性：任一结点的关键字是其子树的最大或者最小值

3.2.3最大堆：父节点的值比孩子结点的值都大

 最小堆：父节点的值比孩子结点的值都小

 3.2.4 升序通过最大堆来实现

     因为，如果选用最小堆实现的话，最小的数是第一个结点，次小的数如论如何选择，剩下的树的结构会乱，不再是最小堆，又需要重新建堆，效率低

    降序通过最小堆来实现

3.2.5建小堆的方法：向下调整算法

    从根节点开始，选出左右孩子较小的那个，跟股结点比较，如果小于父节点就交换值，继续向下调，直到叶子结点结束

这个算法的前提是左右子树都是小堆，才能使用该算法

流程图解：

 如果左右子树不是小堆，那么就从最后一个非叶子结点的子树开始调成小堆

代码（小堆升序）：

  1. #include<stdio.h>
  2. void Swap(int* p1, int* p2)
  3. {
  4. 	int tmp = *p1;
  5. 	*p1 = *p2;
  6. 	*p2 = tmp;
  7. }
  8. void AdjustDown(int* arr, int sz, int root)
  9. {
  10. 	int parent = root;
  11. 	int child = parent * 2 + 1;//默认是左孩子
  12. 	while (child < sz)//child的下标小于sz
  13. 	{
  14. 		//选出两个孩子比较小的那个
  15. 		if ((child + 1 < sz) && (arr[child + 1] < arr[child]))
  16. 		{//child+1是为了避免右孩子的下标超过sz，可能没有右孩子
  17. 			child += 1;//此时的child的右孩子
  18. 		}
  19. 		if (arr[child] < arr[parent])
  20. 		{
  21. 			Swap(&arr[child],&arr[parent]);//如果较小的孩子比双亲节点小，就交换
  22. 			parent = child;//将较小的孩子的坐标给双亲节点
  23. 			child = parent * 2 + 1;//继续找到左孩子进行下一次的调整
  24. 		}
  25. 		else
  26. 		{
  27. 			break;//当没有孩子比双亲小时，结束循环
  28. 		}
  29. 	}
  30.  
  31. }
  32. void HeapSort(int* arr, int sz)
  33. {
  34. 	int i = 0;
  35. 	//将所有子树都调成小堆
  36. 	for (i=(sz-1-1)/2;i>=0;i--)//从倒数第一个非叶子结点的子树开始调整成小堆
  37. 	{
  38. 		AdjustDown(arr,sz, i);
  39. 	}
  40. 	int end = sz - 1;
  41. 	while (end > 0)
  42. 	{
  43. 		Swap(&arr[0], &arr[end]);//将最小的数据和第一个数据交换
  44. 		AdjustDown(arr, end, 0);
  45. 		end--;
  46. 	}
  47. }
  48. int main()
  49. {
  50. 	int arr[] = { 4,2,0,5,9,7,3,1,6,8 };
  51. 	int sz = sizeof(arr) / sizeof(int);
  52. 	HeapSort(arr, sz);
  53. 	int i = 0;
  54. 	for (i = 0; i < sz; i++)
  55. 	{
  56. 		printf("%d ", arr[i]);
  57. 	}
  58. 	return 0;
  59. }

大堆升序只需要将这两个'<'换成'>'即可

 

 四、交换排序

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

4.1冒泡排序

流程图解：

 代码

 (注意控制边界，小心越界)

  1. void BubbleSort(int* arr, int sz)
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	//比较的趟数
  6. 	for (i = 0; i < sz - 1; i++)
  7. 	{
  8. 		//比较的对数
  9. 		int flag = 0;//标记是否已经有序
  10. 		for (j = 0; j < sz - 1 - i; j++)
  11. 		{
  12. 			if (arr[j + 1] < arr[j])
  13. 			{
  14. 				Swap(&arr[j + 1], &arr[j]);
  15. 				flag = 1;
  16. 			}
  17. 		}
  18. 		if (flag == 0)
  19. 		{
  20. 			break;
  21. 		}
  22. 	}
  23. }
  24. int main()
  25. {
  26. 	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  27. 	int sz = sizeof(arr) / sizeof(int);
  28. 	BubbleSort(arr, sz);
  29. 	int i = 0;
  30. 	for (i = 0; i < sz; i++)
  31. 	{
  32. 		printf("%d ", arr[i]);
  33. 	}
  34. 	return 0;
  35. }

4.2快速排序

核心思路：任取待排序 元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所 有元素都排列在相应位置上为止

流程图解：

快速排序（递归）三种方法：

A.挖坑法

核心思路：先将第一个位置的数据保存用key关键字保存，设置一个开始下标为0的begin从左→右找比关键字大的，再设置一个开始下标为最后一个数据的下标end，从右→左找比关键字小的，同时将开始的位置begin设置为坑（pivot），如果找到了，就将该位置的值放在坑（pivot）位置，然后将此位置当做坑，继续上述操作，直到begin与end相遇，此时将关键字的值放在坑位置即可，这是单趟排序，然后从pivot下标的位置开始分区间  ，[0,pivot-1]  和[pivot+1,right],再进行排序（递归）

流程图解

为了提高快排的效率，可以使用三数取中的方法，避免数据是有序的

注意：只能先从右向左找大，然后再从左向右找小

 代码

  1. #include<stdio.h>
  2.  
  3. //三数取中
  4. int GetMidIndex(int* arr, int left, int right)
  5. {
  6. 	int mid = (left + right) >> 1;
  7. 	if (arr[left] < arr[mid])
  8. 	{
  9. 		if (arr[mid] < arr[right])
  10. 		{
  11. 			return mid;
  12. 		}
  13. 		else if (arr[right] < arr[left])
  14. 		{
  15. 			return left;
  16. 		}
  17. 		else
  18. 			return right;
  19. 	}
  20. 	else
  21. 	{
  22. 		if (arr[right] < arr[mid])
  23. 		{
  24. 			return mid;
  25. 		}
  26. 		else if (arr[left] < arr[right])
  27. 		{
  28. 			return left;
  29. 		}
  30. 		else
  31. 			return right;
  32. 	}
  33.  
  34. }
  35.  
  36. void Swap(int* p1, int* p2)
  37. {
  38. 	int tmp = *p1;
  39. 	*p1 = *p2;
  40. 	*p2 = tmp;
  41. }
  42.  
  43. void QuickSort(int* arr, int left, int right)
  44. {
  45. 	//如果没有区间（只有一个数据）就结束
  46. 	if (left >= right)
  47. 		return;
  48. 	int index = GetMidIndex(arr, left, right);
  49. 	Swap(&arr[left], &arr[index]);
  50. 	int begin = left;
  51. 	int end = right;
  52. 	int key = arr[begin];//关键字
  53. 	int pivot = begin;//坑
  54. 	while (begin < end)
  55. 	{
  56. 		//右边找比关键字小的，放在坑位置
  57. 		while ((begin < end) && (arr[end] >= key))
  58. 		{
  59. 			end--;
  60. 		}
  61. 		arr[pivot] = arr[end];//将比关键字小的数据放入坑
  62. 		pivot = end;//将此时end的位置当做坑
  63. 		//左边找比关键字大的放在坑位置
  64. 		while ((begin < end) && (arr[begin] <= key))
  65. 		{
  66. 			begin++;
  67. 		}
  68. 		arr[pivot] = arr[begin];//将比关键字大的放在坑位置
  69. 		pivot = begin;//将此时的begin的位置当做坑
  70. 	}
  71. 	//循环结束后，此时begin和end相等，所指的位置就是坑
  72. 	pivot = begin;
  73. 	arr[pivot] = key;
  74. 	//然后再将关键字左边和右边的分别排序，整体就有序了
  75. 	QuickSort(arr, left, pivot - 1);
  76. 	QuickSort(arr, pivot + 1, right);
  77. }
  78.  
  79.  
  80. int main()
  81. {
  82. 	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  83. 	int sz = sizeof(arr) / sizeof(arr[0]);
  84. 	QuickSort(arr, 0, sz - 1);
  85. 	int i = 0;
  86. 	for (i = 0; i < sz; i++)
  87. 	{
  88. 		printf("%d ", arr[i]);
  89. 	}
  90. 	return 0;
  91. }

B.左右指针法

核心思路：用key指向第一个位置的下标，设置一个开始下标为0的begin从左→右找比key所指数据大的，再设置一个开始下标为最后一个数据的下标end，从右→左找比key所指数据小的，当begin和end都找到数据以后交换数据，然后继续向后找，直到begin和end相遇，此时将end和begin相遇的下标的值和key中的值交换，这是单趟排序，然后从begin和end相遇的下标的位置开始分区间  ，[0,begin-1]  和[begin+1,right],再进行排序（递归）

 代码

  1. #include<stdio.h>
  2.  
  3. //三数取中
  4. int GetMidIndex(int* arr, int left, int right)
  5. {
  6. 	int mid = (left + right) >> 1;
  7. 	if (arr[left] < arr[mid])
  8. 	{
  9. 		if (arr[mid] < arr[right])
  10. 		{
  11. 			return mid;
  12. 		}
  13. 		else if (arr[right] < arr[left])
  14. 		{
  15. 			return left;
  16. 		}
  17. 		else
  18. 			return right;
  19. 	}
  20. 	else
  21. 	{
  22. 		if (arr[right] < arr[mid])
  23. 		{
  24. 			return mid;
  25. 		}
  26. 		else if (arr[left] < arr[right])
  27. 		{
  28. 			return left;
  29. 		}
  30. 		else
  31. 			return right;
  32. 	}
  33.  
  34. }
  35.  
  36.  
  37. void Swap(int* p1, int* p2)
  38. {
  39. 	int tmp = *p1;
  40. 	*p1 = *p2;
  41. 	*p2 = tmp;
  42. }
  43.  
  44.  
  45. int PartSort(int* arr, int left, int right)
  46. {
  47. 	int index = GetMidIndex(arr, left, right);
  48. 	Swap(&arr[left], &arr[index]);
  49. 	int begin = left;
  50. 	int end = right;
  51. 	int key = begin;
  52. 	while (begin < end)
  53. 	{
  54. 		//右边找小
  55. 		while ((begin < end) && (arr[end] >= arr[key]))
  56. 		{
  57. 			end--;
  58. 		}
  59. 		//左边找大
  60. 		while ((begin < end) && (arr[begin] <= arr[key]))
  61. 		{
  62. 			begin++;
  63. 		}
  64. 		//交换begin和end
  65. 		Swap(&arr[begin], &arr[end]);
  66. 	}
  67. 	//交换begin==end时所指数据和key交换
  68. 	Swap(&arr[begin], &arr[key]);
  69. 	return begin;
  70.  
  71. }
  72.  
  73. //快速排序
  74.  
  75. void QuickSort(int* arr, int left, int right)
  76. {
  77. 	if (left >= right)
  78. 		return;
  79. 	int keyIndex = PartSort(arr, left, right);
  80. 	//分治算法  继续对左右区间分别进行排序
  81. 	QuickSort(arr, left, keyIndex-1);
  82. 	QuickSort(arr, keyIndex + 1, right);
  83. }
  84.  
  85.  
  86. int main()
  87. {
  88. 	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  89. 	int sz = sizeof(arr) / sizeof(int);
  90. 	QuickSort(arr, 0, sz - 1);
  91. 	int i = 0;
  92. 	for (i = 0; i < sz; i++)
  93. 	{
  94. 		printf("%d ", arr[i]);
  95. 	}
  96. 	return 0;
  97. }

C.前后指针法

核心思路：设置第一个数据的下标为prev和key，第二个数据的下标为cur，然后让cur开始找比key所指数据小的数据，找到就停下，然后让perv++，为了提高效率，perv++不等于cur，然后再交换perv和cur所指数据，再让cur++，当下标cur>数组最大下标时就结束，此时，将prev所指数据和key所指数据交换，再进行分区间[0,prev-1]和[prev+1,right]  ，分区间再进行上述操作（递归）

流程图解：

 代码

  1. #include<stdio.h>
  2. //三数取中
  3. int GetMidIndex(int* arr, int left, int right)
  4. {
  5. 	int mid = (left + right) >> 1;
  6. 	if (arr[left] < arr[mid])
  7. 	{
  8. 		if (arr[mid] < arr[right])
  9. 		{
  10. 			return mid;
  11. 		}
  12. 		else if (arr[right] < arr[left])
  13. 		{
  14. 			return left;
  15. 		}
  16. 		else
  17. 			return right;
  18. 	}
  19. 	else
  20. 	{
  21. 		if (arr[right] < arr[mid])
  22. 		{
  23. 			return mid;
  24. 		}
  25. 		else if (arr[left] < arr[right])
  26. 		{
  27. 			return left;
  28. 		}
  29. 		else
  30. 			return right;
  31. 	}
  32.  
  33. }
  34.  
  35.  
  36. void Swap(int* p1, int* p2)
  37. {
  38. 	int tmp = *p1;
  39. 	*p1 = *p2;
  40. 	*p2 = tmp;
  41. }
  42.  
  43.  
  44. void QuickSort(int* arr, int left, int right)
  45. {
  46. 	if (left >= right)
  47. 		return;
  48. 	int mid = GetMidIndex(arr, left, right);
  49. 	Swap(&arr[left], &arr[mid]);//避免队列有序
  50. 	int cur = left+1;
  51. 	int prev = left;
  52. 	int key = left;
  53. 	while (cur <= right)
  54. 	{
  55. 		//找比key小的
  56. 		if ((arr[cur] < arr[key]) && (prev++ != cur))//后面避免自己与自己交换
  57. 		{
  58. 			Swap(&arr[cur], &arr[prev]);
  59. 		}
  60. 		cur++;//cur往后继续找
  61. 	}
  62. 	//交换perv与刚开始key的值
  63. 	Swap(&arr[prev], &arr[key]);
  64. 	QuickSort(arr, left, prev - 1);
  65. 	QuickSort(arr, prev + 1, right);
  66.  
  67. }
  68.  
  69. int main()
  70. {
  71. 	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  72. 	int sz = sizeof(arr) / sizeof(int);
  73. 	QuickSort(arr, 0, sz - 1);
  74. 	int i = 0;
  75. 	for (i = 0; i < sz; i++)
  76. 	{
  77. 		printf("%d ", arr[i]);
  78. 	}
  79. 	return 0;
  80. }

五、归并排序（递归）

核心思路：是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列。即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

流程图解

首先需要开辟与原数组大小相同的动态内存空间来存放排序时的数据，从最小的子序列开始排序，将两个子序列依次将较小的值放入开辟的动态数组中，最后再将排好的数据拷贝回原数组

 代码：

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. void _MergeSort(int* arr, int left, int right, int* tmp)
  5. {
  6. 	if (left >= right)
  7. 		return;
  8. 	int mid = (left + right) >> 1;
  9. 	_MergeSort(arr, left, mid, tmp);
  10. 	_MergeSort(arr, mid + 1, right, tmp);
  11. 	int begin1 = left;
  12. 	int end1 = mid;
  13. 	int begin2 = mid + 1;
  14. 	int end2 = right;
  15. 	int index = left;
  16. 	//归并
  17. 	while ((begin1 <= end1) && (begin2 <= end2))
  18. 	{
  19. 		if (arr[begin1] < arr[begin2])
  20. 		{
  21. 			tmp[index++] = arr[begin1++];
  22. 		} 
  23. 		{
  24. 			tmp[index++] = arr[begin2++];
  25. 		}
  26. 	}
  27. 	//如果有一个区间结束，另一个还有数据要继续加到后面
  28. 	while (begin1 <= end1)
  29. 	{
  30. 		tmp[index++] = arr[begin1++];
  31. 	}
  32. 	while (begin2 <= end2)
  33. 	{
  34. 		tmp[index++] = arr[begin2++];
  35. 	}
  36. 	//拷贝回去
  37. 	int i = 0;
  38. 	for (i = left; i <= right; i++)
  39. 	{
  40. 		arr[i] = tmp[i];
  41. 	}
  42. }
  43.  
  44.  
  45. //归并排序
  46. void MergeSort(int* arr, int sz)
  47. {
  48. 	int* tmp = (int*)malloc(sizeof(int) * sz);
  49. 	if (tmp == NULL)
  50. 	{
  51. 		perror("");
  52. 		exit(-1);
  53. 	}
  54. 	else
  55. 	{
  56. 		_MergeSort(arr, 0, sz - 1, tmp);
  57. 		free(tmp);
  58. 		tmp == NULL;
  59. 	}
  60. }
  61. int main()
  62. {
  63. 	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  64. 	int sz = sizeof(arr) / sizeof(int);
  65. 	MergeSort(arr, sz);
  66. 	int i = 0;
  67. 	for (i = 0; i < sz; i++)
  68. 	{
  69. 		printf("%d ", arr[i]);
  70. 	}
  71. 	return 0;
  72. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/658204
推荐阅读
相关标签

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

  

闽ICP备14008679号