• 十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）

    目录

    一、冒泡排序：

    二、插入排序：

    三、选择排序：

    四、希尔排序：

    五、堆排序：

    六、快速排序：

    6.1挖坑法：

    6.2左右指针法

    6.3前后指针法：

    七、归并排序：

    八、桶排序：

    九、计数排序：

    9.1绝对映射：

    9.2现对映射：

    十、基数排序： 

    一、冒泡排序：

    1、思路：通过对待排序序列从前向后（从下标较小的元素开始）,依次对相邻两个元素的值进行两两比较，若发现前一个数大于后一个数则交换，使值较大的元素逐渐从前移向后部，就如果水底下的气泡一样逐渐向上冒。

    2、先以一个数组讲解一下，然后再写代码：
          待排序数组：3，9，-1，10，20
           第一轮排序：
            （1）3，9，-1，10，20      ----3跟9比较，不交换

            （2）3，-1，9，10，20      ----9比 -1大，所以9跟 -1交换

            （3）3，-1，9，10，20      ----9跟10比较，不交换

            （4）3，-1，9，10，20      ----10跟20比较，不交换

               第一轮过后，将20这个最大的元素固定到了最后的位置。

               在第二轮的时候20不参与冒泡。

           第二轮排序：
                因为20的位置已经固定，所以只对前4个进行排序即可：

            （1）-1，3，9，10，20      ----3比 -1大，进行交换

            （2）-1，3，9，10，20      ----3跟9比较，不交换

            （3）-1，3，9，10，20      ----9跟10比较，不交换

                第二轮过后，将第二大的元素固定到了倒数第二个位置

           第三轮排序：
                10和20的位置已经确定，只需对前三个进行排序

            （1）-1，3，9，10，20      ----3和-1比较，不交换

            （2）-1，3，9，10，20      ----3和9比较，不交换

                第三轮过后，将第三大的元素位置确定

           第四轮排序：
                只对前两个元素进行排序

            （1）-1，3，9，10，20      ----3和-1比较，不交换

           第四轮过后，将第四大的元素位置确定，此时总共5个元素，已经排序好4个，从而最后一个自然而然就是排好序的了

    小结：
    设总的元素个数为n，那么由上边的排序过程可以看出：

    （1）总计需要进行（n-1）轮排序，也就是（n-1）次大循环

    （2）每轮排序比较的次数逐轮减少

    （3）如果发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序

    （4）时间复杂度是O(N^2)      在有序的时候，很快，因为有exchange变量优化了代码

             在乱序的时候很慢很慢。

    1. #include<stdio.h>
    2. void swap(int* a, int* b)
    3. {
    4. 	int tmp = *a;
    5. 	*a = *b;
    6. 	*b = tmp;
    7. }
    8. //冒泡排序
    9. void BubbleSort(int* a, int n)
    10. {
    11. 	int end = n - 1;//不能是n，不然会越界
    12. 	while(end)
    13. 	{
    14. 		int exchange = 0;//优化，比较之后没有交换，说明已经排好了，就break循环
    15. 		for (int i = 0; i < end; i++)
    16. 		{
    17. 			if (a[i] < a[i + 1])
    18. 			{
    19. 				swap(&a[i], &a[i + 1]);
    20. 				exchange++;
    21. 			}
    22. 		}
    23. 		if (exchange == 0) break;
    24. 		end--;
    25. 	}
    26. }

    二、插入排序：

    1、思路：

            在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。
      但我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。

    2、举例：

            如下图的插入扑克牌，当摸到7的时候，会不自觉的与前面的数比较，如果比7大，把大的数向后挪动（swap），然后在第一个小于7的后面插入7

     

    1. //插入排序
    2. void InsertSort(int* a, int n)
    3. {
    4. 	for (int i = 1; i < n; i++)
    5. 	{
    6. 		if (a[i] < a[i - 1])//先判断，如果i下标的值大于前面的数，就不进入
    7. 		{
    8. 			int tmp = a[i];
    9. 			int j;
    10. 			for (j = i - 1; j >= 0 && a[j] >tmp; j--)
    11. 			{
    12. 				a[j+1] = a[j];
    13. 			}
    14. 			a[j+1] = tmp;
    15. 		}
    16. 	}
    17. }
    18. //两次循环就可以实现
    19. //内部循环完成一趟的插入
    20. //外层循环完成插入排序

    三、选择排序：

    思路：

    1.内层循环一趟找出最小值的下标，与第一个数交换。重复找小，交换的两个操作。
    2.实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。

    但时间复杂度还是O（N^2），效率还是不高

    1. //选择排序
    2. void SelectSort(int* a, int n)
    3. {
    4. 	for (int i = 0; i < n-1; i++)//i<n-1当它是最后一个数的时候不需要进行交换排序
    5. 	{
    6. 		int min = i;
    7. 		int j;
    8. 		for (j = i; j < n; j++)
    9. 		{
    10. 			if (a[j] < a[min])
    11. 			{
    12. 				min=j;
    13. 			}
    14. 		}
    15. 		swap(&a[i], &a[min]);//交换函数，前面的代码中有出现，我就不重复写了
    16. 	}
    17. }

    四、希尔排序：

    思路：

    1.插入排序的优化版，有一个预排序的过程。让大的数快速的跳到后面，小的数快速的跳到前面。

    2.使待排序列接近有序，然后再对该序列进行一次插入排序。

    3.相当于把直接插入排序中的1换成gap而已。 

    1. //希尔排序
    2. /*步骤：
    3. 1.先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再gap--，重复上述操作。
    4. 2.当gap==1时就是直接插入排序，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。*/
    5.  
    6. void ShellSort(int* a, int n)
    7. {
    8. 	//这里相当于把插入排序的1换成gap
    9. 	int gap = n;
    10. 	while (gap>1)
    11. 	{
    12. 		gap = gap / 3 + 1;
    13. 		for (int i = gap; i < n; i++)
    14. 		{
    15. 			if (a[i] < a[i - gap])
    16. 			{
    17. 				int tmp = a[i];
    18. 				int j;
    19. 				for (j = i - gap; j >= 0 && a[j] > tmp; j-=gap)//这里是j-=gap
    20. 				{
    21. 					a[j + gap] = a[j];
    22. 				}
    23. 				a[j + gap] = tmp;
    24. 			}
    25. 		}
    26. 	}
    27. }

    五、堆排序：

    先来认识堆：

       1.什么是堆？

              大堆：父亲大于儿子          小堆：父亲小于儿子（父亲，儿子是二叉树的概念）

       2.堆的物理结构和逻辑结构？

              物理结构：数组         逻辑结构：完全二叉树

    堆排序包括建堆（向下调整+循环）  堆排序（交换+向下调整）

      1.建堆：

            要建大堆，堆顶的元素和最后一个数交换，然后把size--，就不会破坏堆的结构

      2.向下调整算法：

            比较两个孩子的大小，选出大的孩子，与父亲比较，如果孩子大于父亲，交换。然后把parent=child，child=parent*2+1；向下调整算法一共会调整h-1次

    1. //向下调整算法（要满足它下面的都满足堆，才能用）
    2. void AdjustDown(int* a, int n, int root)
    3. {
    4. 	int parent = root;
    5. 	int child = parent * 2 + 1;
    6. 	while (child < n)
    7. 	{
    8. 		if (child + 1 < n && a[child] < a[child + 1]) child+=1;//把他移到右孩子那里
    9. 		if (a[child] > a[parent])
    10. 		{
    11. 			swap(&a[child], &a[parent]);
    12. 			parent = child;
    13. 			child = parent * 2 + 1;
    14. 		}
    15. 		else break;
    16. 	}
    17. }
    18.  
    19. 堆排序
    20. void HeapSort(int* arr, int n)
    21. {
    22. 	//建大堆
    23.     //从最后一个根开始，就相当于它下面的都满足堆，就可以用向下调整算法
    24. 	for (int i = (n-1-1)/2; i >= 0; i--)//n-1-1是因为数组的最后一个元素下标是n-1
    25. 	{
    26. 		AdjustDown(arr, n, i);
    27. 	}
    28. 	//排序
    29. 	for (int i = n; i > 1; i--)
    30. 	{
    31. 		swap(&arr[0],&arr[i - 1]);
    32. 		AdjustDown(arr, i-1, 0);
    33. 	}
    34. }

    六、快速排序：

    三种快排方法：（一定要自己尝试着去写，会有一些坑，自己写才可以体会）

    1.挖坑法

    2.左右指针法

    3.前后指针法

    6.1挖坑法：

    1.思想：

            记第一个数为key，要调整key的位置，使得左边的都要比key的小，右边的数都比key的大。

    2.步骤：

            选出一个数据（一般是最左边或是最右边的）存放在key变量中，在该数据位置形成一个坑
            还是定义一个left和一个right，left从左向右走（当遇到大于key的值时停下来）。right从右向左走（当遇到小于key的值时停下来）。（若在最左边挖坑，则需要right先走；若在最右边挖坑，则需要left先走） 

            把right的那个小的数放在坑中，在把left那个位置的值放在right那个位置中

            重复操作，直到left>right时结束，完成一趟，把key放在了正确的位置

            最后用分治思想，分成左边和右边，递归。

     

    1. //1.挖坑法的快速排序
    2. void QuickSort(int* a,int left,int right)
    3. {
    4. 	if (left >= right)//不能写成pivot==left，pivot-1与left不匹配，会报错
    5. 	{
    6. 		return;
    7. 	}
    8. 	int begin = left,end = right;
    9. 	int key = a[begin];//挖了一个关键字
    10. 	int pivot = begin;//挖了一个坑
    11. 	while (begin < end)
    12. 	{
    13. 		//右边找小，一定要先右边找小,放在pivot
    14. 		while (begin < end&&a[end] >= key)//在这里也要判断begin < end,因为这里面end--
    15. 		{
    16. 			end--;
    17. 		}
    18. 		//小的放在左边的坑里，然后形成新的坑位
    19. 		a[pivot] = a[end];
    20. 		pivot = end;
    21. 		//左边找大
    22. 		while (begin < end && a[begin] <= key)
    23. 		{
    24. 			begin++;
    25. 		}
    26. 		a[pivot] = a[begin];
    27. 		pivot = begin;	
    28. 	}
    29. 	//begin==end	
    30. 	a[pivot] = key;
    31.  
    32. 	//[left,right]
    33. 	//[left,pivot-1]  pivot  [pivot+1,right]
    34. 	//如果左子区间和右子区间都有序，就全部有序。那就分治递归。
    35. 	QuickSort(a, left, pivot - 1);
    36. 	QuickSort(a, pivot+1, right);
    37. }

    6.2左右指针法

    思路：
    1、选出一个key，一般是最左边或是最右边的。
    2、定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）（考虑到最后的时候相遇点的和key交换）。
    3、在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）
    4.此时key的左边都是小于key的数，key的右边都是大于key的数
    5.将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时

    1. void QuickSort(int* a, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 	{
    5. 		return;
    6. 	}
    7. 	int begin = left, end = right;
    8. 	int key = begin;//这里与挖坑法不同的地方，因为要交换key的那个数组中那个位置的数，而不是值
    9. 	while (begin < end)
    10. 	{
    11. 		while (begin < end && a[end] >= a[key])
    12. 		{
    13. 			end--;
    14. 		}
    15. 		while (begin < end && a[begin] <= a[key])
    16. 		{
    17. 			begin++;
    18. 		}
    19. 		Swap(&a[begin], &a[end]);
    20. 	}
    21. 	Swap(&a[begin], &a[key]);
    22. 	QuickSort(a, left, begin - 1);
    23. 	QuickSort(a, begin + 1, right);
    24. }

    6.3前后指针法：

    思路：
    1、选出一个key，一般是最左边。
    2、起始时，prev指针指向序列开头，cur指针指向prev+1。
    3、让cur一直向前走，当遇到小于a[key]时，让prev向前走一格（这个值一定大于a[key]，因为是cur走过的），然后a[cur]和a[prev]交换。

    经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。

    然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去

    用if(left>right)

    {
            reurn;

    }//跳出递归

    1. void QuickSort(int* a, int left,int right)
    2. {
    3. 	if (left >= right)
    4. 	{
    5. 		return;
    6. 	}
    7. 	int index=GetMidIndex(a,left, right);
    8. 	swap(&a[left], &a[index]);
    9. 	int key = left;
    10. 	int prev = left;
    11. 	int cur = left+1;
    12. 	while (cur <= right)
    13. 	{
    14. 		if (a[cur] < a[key])
    15. 		{
    16. 			prev++;
    17. 			swap(&a[cur], &a[prev]);
    18. 		}
    19. 		/*可以简写成cur++，   
    20. 		但是当时一定要注意不要放在if语句的前面，因为if语句里面有让cur与prev交换的，cur==right跳出循环，但是a[cur]超过数组的范围，会越界范围。
    21.         while (cur<=right&&a[cur] >= a[key])   
    22. 		{
    23. 			cur++;
    24. 		}*/
    25.         cur++;
    26. 	}
    27. 	swap(&a[prev], &a[key]);
    28. 	QuickSort(a, left, prev - 1);
    29. 	QuickSort(a, prev+1,right);
    30. }

     6.4优化快排

    三数取中法：取左端、中间、右端三个数，然后进行比较，将中值数当做key

    否则有序时时间复杂度为O(N^2)

    三数取中法可以套入三种方法中，这里我就写一种

    1. //三数取中
    2. int GetMidIndex(int* a, int left, int right)
    3. {
    4. 	int mid = (left + right) / 2;
    5. 	if (a[mid] >= a[left])
    6. 	{
    7. 		if (a[mid] <= a[right])
    8. 		{
    9. 			return mid;
    10. 		}
    11. 		else
    12. 		{
    13. 			if (a[right] >= a[left])
    14. 			{
    15. 				return right;
    16. 			}
    17. 			else
    18. 			{
    19. 				return left;
    20. 			}
    21. 		}
    22. 	}
    23. 	else//a[left]>a[mid]
    24. 	{
    25. 		if (a[right] >= a[left])
    26. 		{
    27. 			return left;
    28. 		}
    29. 		else
    30. 		{
    31. 			if (a[right] >= a[mid])
    32. 			{
    33. 				return right;
    34. 			}
    35. 			else
    36. 			{
    37. 				return mid;
    38. 			}
    39. 		}
    40. 	}
    41. }
    42.  
    43. //交换
    44. void swap(int* a, int* b)
    45. {
    46. 	int tmp = *a;
    47. 	*a = *b;
    48. 	*b = tmp;
    49. }
    50.  
    51. //前后指针法
    52. void QuickSort(int* a, int left,int right)
    53. {
    54. 	if (left >= right)
    55. 	{
    56. 		return;
    57. 	}
    58. 	int index=GetMidIndex(a,left, right);
    59. 	swap(&a[left], &a[index]);
    60. 	int key = left;
    61. 	int prev = left;
    62. 	int cur = left+1;
    63. 	while (cur <= right)
    64. 	{
    65. 		if (a[cur] < a[key])
    66. 		{
    67. 			prev++;
    68. 			swap(&a[cur], &a[prev]);
    69. 		}
    70. 		cur++;
    71. 	}
    72. 	swap(&a[prev], &a[key]);
    73. 	QuickSort(a, left, prev - 1);
    74. 	QuickSort(a, prev+1,right);
    75. }

    七、归并排序：

    思路：

    1.不断的分割数据，让数据的每一段都有序（一个数据相当于有序）

    2.当所有子序列有序的时候，在把子序列归并，形成更大的子序列，最终整个数组有序。

     ！！！需要开一个_MergeSort,而不是直接在MergeSort中直接递归，是因为MergeSort中有一个malloc

    归并排序很像二叉树中的后序思想，先递归，递归到最后的时候再合并。！！！

    1. //归并排序
    2. void _MergeSort(int* a, int left, int right, int* tmp)//在这个函数中调用递归{
    3. 	if (left >= right)
    4. 	{
    5. 		return;
    6. 	}
    7. 	int mid = (left + right) >> 1;
    8. 	_MergeSort(a, left, mid, tmp);
    9. 	_MergeSort(a, mid+1, right, tmp);
    10. 	//合并
    11. 	int begin1 = left, end1 = mid;
    12. 	int begin2 = mid + 1, end2 = right;
    13. 	int i = left;
    14. 	while (begin1 <= end1 && begin2 <= end2)
    15. 	{
    16. 		if (a[begin1] <= a[begin2])
    17. 		{
    18. 			tmp[i++] = a[begin1++];
    19. 		}
    20. 		else
    21. 		{
    22. 			tmp[i++] = a[begin2++];
    23. 		}
    24. 	}
    25. 	while (begin1 <= end1)
    26. 	{
    27. 		tmp[i++] = a[begin1++];
    28. 	}
    29. 	while (begin2 <= end2)
    30. 	{
    31. 		tmp[i++] = a[begin2++];
    32. 	}
    33. 	for (int j = left; j <= right; j++)
    34. 	{
    35. 		a[j] = tmp[j];
    36. 	}
    37. }
    38. void MergeSort(int* a, int n)
    39. {
    40. 	int* tmp = (int*)malloc(sizeof(int) * n);
    41. 	_MergeSort(a, 0, n - 1, tmp);
    42. 	free(tmp);
    43. }

    八、桶排序：

    思路：大问题化小

    桶排序 (Bucket sort)或所谓的箱排序，是一种分块的排序算法，工作的原理是将数组分到有限数量的桶里，每个桶的大小都相等。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）

    把待排序序列（数组）中的数据根据函数映射方法分配到若干个桶中，在分别对各个桶进行排序，最后依次按顺序取出桶中的数据。
    适用于数据分配均匀，数据比较大，相对集中的情况。

    1. //桶排序
    2. void bucket_sort(int a[],int size,int bucket_size) {
    3. 	int i,j;        //数组，数组长度，桶的大小
    4.  
    5.                         //定义动态的指针数组
    6. 	KeyNode **bucket_num = (KeyNode **)malloc(bucket_size * sizeof(KeyNode*));
    7.  
    8. 	for(i = 0;i < bucket_size;i++) 
    9. 	{
    10. 		bucket_num[i] = (KeyNode*)malloc(sizeof(KeyNode));//为每个链表定义头结点 
    11. 		bucket_num[i]->num = 0;   
    12. 		bucket_num[i]->next = NULL;   //指针变量初始化为空
    13. 	}
    14.  
    15. 	for(j = 0;j < size;j++) //准备插入
    16. 	{
    17. 		KeyNode *node = (KeyNode *)malloc(sizeof(KeyNode));//定义一个节点 
    18. 		node->num = a[j];    //数据域存数据 
    19. 		node->next = NULL;	//指向空
    20. 		
    21. 		int index = a[j]/100;  //映射函数 计算桶号
    22. 		
    23. 		KeyNode *p = bucket_num[index];//p指向链表的头
    24.        
    25.         //链表结构的插入排序
    26. 		while(p->next != NULL && p->next->num <= node->num)
    27. 		{
    28. 			p = p->next;	//1.链表为空，p->next==NULL，进入不了循环 
    29. 		}					//2.链表不为空，因为链表从无开始按顺序插入，数据为有序的，
    30. 							//可以找到    前一个节点 <= node <=后一个节点
    31. 		
    32. 		//节点插入链表 
    33. 		node->next = p->next;
    34. 		p->next = node;
    35. 		(bucket_num[index]->num)++;	//记录一下该链表中有几个有效节点 
    36.  
    37. 	}
    38. 	//打印结果
    39. 	KeyNode * k = NULL;  //定义一个空的结构体指针用于储存输出结果
    40. 	for(i = 0;i < bucket_size;i++)
    41.     {
    42.         //for(k = bucket_num[i]->next;k!=NULL;k=k->next)//通过最后一个指针指向空
    43.         k = bucket_num[i]->next;
    44.         for(int m=0;m<bucket_num[i]->num;m++)   //通过头指针记录节点数
    45.         {
    46.             printf("%d ",k->num);
    47.             k=k->next;
    48.         			
    49.     }		
    50. 	printf("\n");
    51. }

    九、计数排序：

    一种特殊的排序，唯一种没有比较的排序（指没有前后比较，还是有交换的）

    以数组的下标当做数值，有这个数的时候a[i]++;

     局限：适用于整数。数要求集中（否则空间的浪费大）

    9.1绝对映射：

    1. int * countingSort1(int arr[],int count,int max) {
    2.     int index = 0;
    3.     int *tmpArr = (int *)malloc(max*sizeof(int));
    4.     int *result = (int *)malloc(max*sizeof(int));
    5.     
    6.     for(int k = 0;k<max;k++) {
    7.         tmpArr[k] = 0;
    8.     }
    9.     
    10.     for (int i = 0; i<count; i++) {
    11.         tmpArr[arr[i]]++;
    12.     }
    13.     for (int j = 0; j<max; j++) {
    14.         while (tmpArr[j]) {
    15.             result[index++] = j;
    16.             tmpArr[j]--;
    17.         }
    18.     }
    19.     free(tmpArr);
    20.     tmpArr = NULL;
    21.     return result;
    22. }

    9.2现对映射：

    1. void CountSort(int* a, int n)
    2. {
    3. 	int max = a[0], min = a[0];
    4. 	for (int i = 0; i < n; i++)
    5. 	{
    6. 		if (a[i] > max) max = a[i];
    7. 		if (a[i] < min) min = a[i];
    8. 	}
    9. 	int range = max - min + 1;
    10. 	int* count = (int*)malloc(sizeof(int) * range);
    11. 	memset(count, 0, sizeof(int) * range);
    12. 	for (int i = 0; i < n; i++)
    13. 	{
    14. 		count[a[i] - min]++;
    15. 	}
    16. 	int i = 0;
    17. 	for (int j = 0; j < range; j++)
    18. 	{
    19. 		while (count[j]--)
    20. 		{
    21. 			a[i++] = j + min;
    22. 		}
    23. 	}
    24. 	free(count);
    25. }

    十、基数排序： 

    原理：是将整数按位数切割成不同的数字，然后按每个位数分别比较。

    1. #include<math.h>
    2. testBS()
    3. {
    4.     inta[] = {2, 343, 342, 1, 123, 43, 4343, 433, 687, 654, 3};
    5.     int *a_p = a;
    6.     //计算数组长度
    7.     intsize = sizeof(a) / sizeof(int);
    8.     //基数排序
    9.     bucketSort3(a_p, size);
    10.     //打印排序后结果
    11.     inti;
    12.     for(i = 0; i < size; i++)
    13.     {
    14.         printf("%d\n", a[i]);
    15.     }
    16.     intt;
    17.     scanf("%d", t);
    18. }
    19. //基数排序
    20. voidbucketSort3(int *p, intn)
    21. {
    22.     //获取数组中的最大数
    23.     intmaxNum = findMaxNum(p, n);
    24.     //获取最大数的位数，次数也是再分配的次数。
    25.     intloopTimes = getLoopTimes(maxNum);
    26.     inti;
    27.     //对每一位进行桶分配
    28.     for(i = 1; i <= loopTimes; i++)
    29.     {
    30.         sort2(p, n, i);
    31.     }
    32. }
    33. //获取数字的位数
    34. intgetLoopTimes(intnum)
    35. {
    36.     intcount = 1;
    37.     inttemp = num / 10;
    38.     while(temp != 0)
    39.     {
    40.         count++;
    41.         temp = temp / 10;
    42.     }
    43.     returncount;
    44. }
    45. //查询数组中的最大数
    46. intfindMaxNum(int *p, intn)
    47. {
    48.     inti;
    49.     intmax = 0;
    50.     for(i = 0; i < n; i++)
    51.     {
    52.         if(*(p + i) > max)
    53.         {
    54.             max = *(p + i);
    55.         }
    56.     }
    57.     returnmax;
    58. }
    59. //将数字分配到各自的桶中，然后按照桶的顺序输出排序结果
    60. voidsort2(int *p, intn, intloop)
    61. {
    62.     //建立一组桶此处的20是预设的根据实际数情况修改
    63.     intbuckets[10][20] = {};
    64.     //求桶的index的除数
    65.     //如798个位桶index=(798/1)%10=8
    66.     //十位桶index=(798/10)%10=9
    67.     //百位桶index=(798/100)%10=7
    68.     //tempNum为上式中的1、10、100
    69.     inttempNum = (int)pow(10, loop - 1);
    70.     inti, j;
    71.     for(i = 0; i < n; i++)
    72.     {
    73.         introw_index = (*(p + i) / tempNum) % 10;
    74.         for(j = 0; j < 20; j++)
    75.         {
    76.             if(buckets[row_index][j] == NULL)
    77.             {
    78.                 buckets[row_index][j] = *(p + i);
    79.                 break;
    80.             }
    81.         }
    82.     }
    83.     //将桶中的数，倒回到原有数组中
    84.     intk = 0;
    85.     for(i = 0; i < 10; i++)
    86.     {
    87.         for(j = 0; j < 20; j++)
    88.         {
    89.             if(buckets[i][j] != NULL)
    90.             {
    91.                 *(p + k) = buckets[i][j];
    92.                 buckets[i][j] = NULL;
    93.                 k++;
    94.             }
    95.         }
    96.     }
    97. }
  • 相关阅读:
    详细解读-Spring响应处理
    无人自动驾驶技术研发中具有重要性
    编程题练习@9-7
    2022钉钉杯初赛A题（银行卡电信诈骗危险预测）
    mysql物理备份步骤
    子网掩码计算工具：IPSubnetter
    深度学习简述
    大数据在车联网行业的实践与应用
    鸿蒙HarmonyOS实战-ArkTS语言基础类库（容器类库）
    Flask框架——基于Celery的后台任务
  • 原文地址：https://blog.csdn.net/2301_80215560/article/details/136604635