Estrutura de dados e entrevista de algoritmo: A complexidade de tempo do algoritmo de classificação baseado em comparação é O(nlogn) no pior caso.Existe um algoritmo mais rápido? (dica: classificação por contagem, classificação por raiz)

Estrutura de dados e entrevista de algoritmo: A complexidade de tempo do algoritmo de classificação baseado em comparação é O(nlogn) no pior caso.Existe um algoritmo mais rápido? (dica: classificação por contagem, classificação por raiz)

Introdução: A complexidade de tempo do algoritmo de ordenação baseado em comparação é O(nlogn) no pior caso.Existe um algoritmo mais rápido? (dica: classificação por contagem, classificação por raiz)

Radix sort é um algoritmo de ordenação com complexidade de tempo O(nlogn), onde d é o número de dígitos do maior número na matriz a. A classificação de raiz é mais rápida do que a classificação de comparação se o comprimento do número d for pequeno.

A ideia de implementação da ordenação radix é a seguinte:

1. Use uma matriz de balde para registrar o número de ocorrências de cada número possível (aqui, suponha que o intervalo de valores esteja entre 0 e 9).
2. Classifique a matriz original a de acordo com unidades, dezenas, centenas, milhares... Para um certo "número atual de dígitos", pode-se usar classificação por contagem ou classificação por balde. Após esta rodada de classificação, a matriz original a foi classificada.

A seguir está o código para implementar a ordenação radix em C++, com comentários detalhados:

#include <iostream>
#include <vector>

using namespace std;

void radix_sort(vector<int>& a) {
    int n = a.size();
    if (n <= 1) return;

    // 获取数组中的最大值
    int max_val = a[0];
    for (int i = 1; i < n; ++i) {
        max_val = max(max_val, a[i]);
    }

    // 计算出最大值的长度
    int k = 0;
    while (max_val > 0) {
        max_val /= 10;
        ++k;
    }

    // 建立桶数组并进行基数排序
    vector<int> bucket(a.size());
    vector<int> count(10);

    // 每一轮循环按照不同的位数进行排序
    for (int i = 0, r = 1; i < k; ++i, r *= 10) {
        // 将桶清零
        fill(count.begin(), count.end(), 0);

        // 统计出现次数
        for (int j = 0; j < n; ++j) {
            int c = (a[j] / r) % 10;
            ++count[c];
        }

        // 计算前缀和
        for (int j = 1; j <= 9; ++j) {
            count[j] += count[j - 1];
        }

        // 按顺序将数放到桶中
        for (int j = n - 1; j >= 0; --j) {
            int c = (a[j] / r) % 10;
            bucket[--count[c]] = a[j];
        }

        // 从桶中取回数据
        for (int j = 0; j < n; ++j) {
            a[j] = bucket[j];
        }
    }
}

int main() {
    vector<int> a = {7, 6, 5, 4, 3, 2, 1, 0};
    radix_sort(a);
    for (int i = 0; i < a.size(); ++i) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

Com a ajuda de duas estruturas de dados "bucket" e "count", o algoritmo realiza o algoritmo de ordenação radix com complexidade de tempo O(dn). Para lidar convenientemente com os números na matriz, podemos convertê-los em strings e, em seguida, operá-los.

• Java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Main {
    
    
    public static void radixSort(int[] a) {
    
    
        int n = a.length;
        if (n <= 1) return;

        // 获取数组中的最大值
        int max_val = a[0];
        for (int i = 1; i < n; ++i) {
    
    
            max_val = Math.max(max_val, a[i]);
        }

        // 计算出最大值的位数
        int k = 0;
        while (max_val > 0) {
    
    
            max_val /= 10;
            ++k;
        }

        // 建立桶数组并进行基数排序
        int[] bucket = new int[a.length];
        int[] count = new int[10];

        // 每一轮循环按照不同的位数进行排序
        for (int i = 0, r = 1; i < k; ++i, r *= 10) {
    
    
            // 将桶清零
            Arrays.fill(count, 0);

            // 统计出现次数
            for (int j = 0; j < n; ++j) {
    
    
                int c = (a[j] / r) % 10;
                ++count[c];
            }

            // 计算前缀和
            for (int j = 1; j < 10; ++j) {
    
    
                count[j] += count[j - 1];
            }

            // 按顺序将数放到桶中
            for (int j = n - 1; j >= 0; --j) {
    
    
                int c = (a[j] / r) % 10;
                bucket[--count[c]] = a[j];
            }

            // 从桶中取回数据
            for (int j = 0; j < n; ++j) {
    
    
                a[j] = bucket[j];
            }
        }
    }

    public static void main(String[] args) {
    
    
        int[] a = {
    
    7, 6, 5, 4, 3, 2, 1, 0};
        radixSort(a);
        for (int i = 0; i < a.length; ++i) {
    
    
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
}