【数据结构】堆、计数、桶、基数排序的实现

1. 堆排序

1.1 算法思想

堆排序(Heap Sort)是一种基于堆数据结构的排序算法。其核心思想是将待排序的元素构建成一个最大堆或最小堆,然后依次将堆顶元素与堆中最后一个元素交换,并重新调整堆,使得剩余元素重新满足堆的性质。重复这个过程直到所有元素都被取出,就得到了一个有序的序列。

1.2 算法步骤

  1. 建立一个大根堆(升序)。
  2. 将堆顶元素与堆底末尾元素交换,这时待排序中最大元素成功放到正确的位置,并且将堆中待排序的元素个数 size --。
  3. 然后对堆顶元素进行向下调整,使剩余待排序元素重新形成一个大根堆。
  4. 重复步骤2,3直至待排序元素个数 size = 1,排序完成。

1.3 动画演示

1.4 代码实现

复制代码
void AdjustDown(int* arr, int n, int parent)
{
	int child = 2 * parent + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child] < arr[child + 1])
		{
			child++;
		}
		if (arr[child] > arr[parent])
		{
			swap(&arr[child], &arr[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* arr, int n)
{
	//向下调整建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		end--;
	}
}

2. 计数排序

2.1 算法思想

计数排序(Counting Sort)是一种非比较性的排序算法,适用于一定范围内的整数排序。其核心思想是统计每个元素出现的次数,然后根据这个统计信息,将元素放置到正确的位置上。

2.2 算法步骤

  1. 找出待排序数组中的最大值max和最小值min。

  2. 创建一个长度为max - min + 1的计数数组count,用于存储每个元素出现的次数。

  3. 遍历待排序数组,统计每个元素出现的次数,将其存储在计数数组中相应的位置上。

  4. 根据计数数组中的统计信息,将待排序数组重新排列。

  5. 将排好序的元素从计数数组中放回待排序数组中。

2.3 动画演示

2.4 代码实现

复制代码
void CountSort(int* arr, int n)
{
	//找出最大与最小元素
	int max = arr[0];
	int min = arr[0];
	for (int i = 0; i < n; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
		if (arr[i] < min)
		{
			min = arr[i];
		}
	}

	int range = max - min + 1;
	int* countArray = (int*)malloc(sizeof(int) * range);
	if (countArray == NULL)
	{
		perror("malloc fail:");
		return;
	}
	//初始化
	memset(countArray, 0, sizeof(int) * range);
	//统计各元素出现次数
	for (int i = 0; i < n; i++)
	{
		countArray[arr[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (countArray[i]--)
		{
			arr[j++] = i + min;
		}
	}
}

3. 桶排序

3.1 算法思想

桶排序(Bucket Sort) 是一种适用于一定范围内的元素排序的算法。其核心思想是将待排序的元素分配到有限数量的桶中,然后分别对每个桶中的元素进行排序,最后按照顺序将各个桶中的元素依次取出,得到有序序列。

3.2 算法步骤

  1. 确定桶的每个桶的元素个数和桶的数量,将待排序数组中的元素分配到对应的桶中。

每个桶的元素个数:bucketsize=(max-min)/n+1,max,min,n分别为数组最大元素,最小元素,以及元素个数。每个桶的范围就是:[min,bucketsize),[min+bucketsize,min+2*bucketsize)...

桶的数量:bucketnum=(max-min)/bucketsize+1,bucketsize为每个桶的元素个数。

  1. 对每个桶中的元素进行排序,可以选择其他排序算法。

  2. 将各个桶中的元素按照顺序取出,组成最终的有序序列。

为什么 bucketnum 与 bucketsize 的计算最后要加1

  1. 首先是因为除法运算的结果是可以等于0的,而桶的数量与桶最大容纳个数是不可能为0,所以需要加1。

  2. 其次我们默认每个桶的范围是左闭右开区间,如果不加1最大的元素可能无法进入桶内。

3.3 动画演示

3.4 代码实现

复制代码
void BucketSort(int* arr, int n)
{
	//找出最大与最小元素
	int max = arr[0];
	int min = arr[0];
	for (int i = 0; i < n; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
		if (arr[i] < min)
		{
			min = arr[i];
		}
	}

	//每个桶的元素最大个数
	int bucketsize = (max - min) / n + 1;
	//桶的个数
	int bucketnum = (max - min) / bucketsize + 1;
	int bucket[bucketnum][bucketsize];
	int bucketcount[bucketnum];//每个桶当前元素个数计数器
	memset(bucket, 0, sizeof(bucket));
	memset(bucketcount, 0, sizeof(bucketcount));
	//将元素放入桶中
	for (int i = 0; i < n; i++)
	{
		int index = (arr[i] - min) / bucketsize;//第几个桶
		bucket[index][bucketcount[index]] = arr[i];
		bucketcount[index]++;//第几个桶的个数++
	}
	for (int i = 0; i < bucketnum; i++)
	{
		QuickSort(bucket[i], 0, bucketcount[i] - 1);
	}
	for (int i = 0; i < bucketnum; i++)
	{
		int t = 0;
		for (int j = 0; j < bucketcount[i]; j++)
		{
			arr[t++] = bucket[i][j];
		}
	}
}

4. 基数排序

4.1 算法思想

基数排序(Radix Sort)是一种非比较性的排序算法,适用于对整数或字符串等元素进行排序。其核心思想是将待排序的元素按照位数进行分组,然后依次对每个位数进行稳定的排序,最终得到有序序列。

4.2 算法步骤

  1. 确定待排序元素的最大位数,通常通过计算最大元素的位数或者最高位数来确定。

  2. 从最低位开始,依次对元素按照当前位上的数值进行分组,并且统计每个数组出现次数记录在counter数组中。(十进制的位范围为 0~9 ,因此需要长度为 10 的统计数组)

  3. 利用前缀和counter[i] = counter[i - 1] + counter[i]求出每个对应数值的最后一个元素的下标索引。

  4. 倒序遍历,通过每个元素arr[i]的当前位上的值求出下标索引j=counter[i]-1,并将该元素存入新的数组ret[j]=arr[i]中,最后以ret数组覆盖原数组达到排序该位数的目的。

  5. 重复步骤2,3,4直至达到最大元素的位数,排序完毕。

  1. 按个位排序
  1. 按十位排序

4.3 动画演示

4.4 代码实现

复制代码
//获取当前位数的值
int digit(int num, int exp) 
{
	return (num / exp) % 10;
}

//对当前位数进行排序
void CountSortDigit(int arr[], int n, int exp) {
	// 十进制的位范围为 0~9 ,因此需要长度为 10 的统计数组
	int* counter = (int*)malloc((sizeof(int) * 10)); 
	if (counter == NULL)
	{
		perror("malloc fail:");
		return;
	}

	//初始化
	memset(counter, 0, sizeof(int) * n);
	// 统计 0~9 各数字的出现次数
	for (int i = 0; i < n; i++) 
	{
		int d = digit(arr[i], exp);
		counter[d]++;
	}
	// 求前缀和,将"出现个数"转换为"数组索引"
	for (int i = 1; i < 10; i++) 
	{
		counter[i] += counter[i - 1];
	}

	// 倒序遍历,根据统计数组内统计结果,将各元素填入 ret
	int* ret = (int)malloc(sizeof(int) * n);
	if (ret == NULL)
	{
		perror("malloc fail:");
		return;
	}
	memset(ret, 0, sizeof(int) * n);
	for (int i = n - 1; i >= 0; i--) 
	{
		int d = digit(arr[i], exp);
		int j = counter[d] - 1; // 获取 d 在数组中的索引 j
		ret[j] = arr[i]; // 将当前元素填入索引 j
		counter[d]--; 
	}
	// 覆盖原数组
	for (int i = 0; i < n; i++) 
	{
		arr[i] = ret[i];
	}
}

void RadixSort(int*arr, int n) 
{
	// 获取数组的最大元素,用于判断最大位数
	int max = arr[0];
	for (int  i = 0; i < n ; i++) 
	{
		if (arr[i] > max) 
		{
			max = arr[i];
		}
	}

	// 按照从低位到高位的顺序遍历
	for (int exp = 1; max >= exp; exp *= 10)
	{
		CountSortDigit(arr, n, exp);
	}
}
相关推荐
敲代码的嘎仔3 小时前
牛客算法基础noob59 简写单词
java·开发语言·数据结构·程序人生·算法·leetcode·学习方法
少许极端3 小时前
算法奇妙屋(四)-归并分治
java·算法·排序算法·分治·归并
fly spider3 小时前
3.数组算法
算法
Haohao+++6 小时前
Stable Diffusion原理解析
人工智能·深度学习·算法
ideaout技术团队9 小时前
leetcode学习笔记2:多数元素(摩尔投票算法)
学习·算法·leetcode
代码充电宝9 小时前
LeetCode 算法题【简单】283. 移动零
java·算法·leetcode·职场和发展
不枯石12 小时前
Matlab通过GUI实现点云的均值滤波(附最简版)
开发语言·图像处理·算法·计算机视觉·matlab·均值算法
不枯石12 小时前
Matlab通过GUI实现点云的双边(Bilateral)滤波(附最简版)
开发语言·图像处理·算法·计算机视觉·matlab
白水先森14 小时前
C语言作用域与数组详解
java·数据结构·算法