Estructura de datos: algoritmo de clasificación común (7): clasificación de base (implementación de C ++)

Estructura de datos: algoritmo de clasificación común (7): clasificación de base

1. Idea básica:

Unifique todos los valores que se van a comparar (enteros positivos) con la misma longitud de dígito y ceros rellenos delante de los dígitos más cortos. Luego, comenzando desde el bit más bajo, ordene una vez en secuencia. De esta forma, desde el orden más bajo hasta el más alto, la secuencia se convierte en una secuencia ordenada.

2. Ejemplos

Código de ejemplo:

#include<iostream>
using namespace std;
//辅助函数，求数据的最大位数
int maxbit(int data[], int n)
{
	int maxData = data[0];              ///< 最大数
	/// 先求出最大数，再求其位数，这样有原先依次每个数判断其位数，稍微优化点。
	for (int i = 1; i < n; ++i)
	{
		if (maxData < data[i])
			maxData = data[i];
	}
	int d = 1;
	int p = 10;
	while (maxData >= p)
	{
		//p *= 10; // Maybe overflow
		maxData /= 10;
		++d;
	}
	return d;
}
//基数排序
void radixsort(int data[], int n) 
{
	int d = maxbit(data, n);
	int *tmp = new int[n];
	int *count = new int[10]; //计数器
	int i, j, k;
	int radix = 1;
	for (i = 1; i <= d; i++) //进行d次排序
	{
		for (j = 0; j < 10; j++)
			count[j] = 0; //每次分配前清空计数器
		for (j = 0; j < n; j++)
		{
			k = (data[j] / radix) % 10; //统计每个桶中的记录数
			count[k]++;
		}
		for (j = 1; j < 10; j++)
			count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
		for (j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中
		{
			k = (data[j] / radix) % 10;
			tmp[count[k] - 1] = data[j];
			count[k]--;
		}
		for (j = 0; j < n; j++) //将临时数组的内容复制到data中
			data[j] = tmp[j];
		radix = radix * 10;
	}
	delete[]tmp;
	delete[]count;
}
//打印数组
void print_arr(int data[],int n)
{
	for (int i = 0; i < n; i++)
	{
		cout<< data[i] << " ";
	}
	cout << endl;
}
//主函数
int main()
{
	int a[12] = { 27, 91, 1, 97, 17, 23, 84, 28, 72, 5, 67, 25 };
	cout << "排序前数组为：";
	print_arr(a, 12);
	radixsort(a, 12);
	cout << "排序后数组为：";
	print_arr(a, 12);
	return 0;
}

3. Resumen:

Complejidad de tiempo: dados n d dígitos (es decir, d códigos de clave, el rango de valores del código de clave es r), y la ordenación por base necesita comparar cada bit del elemento, la complejidad es O (d (n + r) ), la complejidad temporal de una ronda de asignación cíclica es O (n) y la complejidad temporal de una ronda de recolección cíclica es O®, se requiere un total de d ciclos para la asignación y recolección, es decir, la complejidad temporal es O (d (n + r) )