b'\n_START_ARTICLE_\nCounting sort\n_START_SECTION_\nPseudoc\xc3\xb3digo\n_START_PARAGRAPH_\n//k \xc3\xa9 o maior valor do vetor A_NEWLINE__NEWLINE_//Criar vetor auxiliar com k+1 elementos e inicializar com zeros_NEWLINE_for i \xe2\x86\x90 0 to k_NEWLINE_    do C[i]\xe2\x86\x900_NEWLINE_    _NEWLINE_for j \xe2\x86\x90 1 to length[A]_NEWLINE_    do C[A[j]] \xe2\x86\x90 C[A[j]] + 1_NEWLINE_//Agora C[i] contem o numero de elementos igual a i._NEWLINE__NEWLINE_for i \xe2\x86\x90 1 to k_NEWLINE_    do C[i] \xe2\x86\x90 C[i] + C[i - 1]_NEWLINE_//Agora C[i] contem o numero de elementos menor que ou igual a i._NEWLINE__NEWLINE_for j \xe2\x86\x90 length[A] downto 1_NEWLINE_    do B[C[A[j]]] \xe2\x86\x90 A[j]_NEWLINE_        C[A[j]] \xe2\x86\x90 C[A[j]] - 1_NEWLINE_        _NEWLINE_//Pseudocodigo do livro "Introduction to Algorithms" _NEWLINE_//de Thomas H. Cormen...[et al.] - 2nd ed._NEWLINE_//The MIT Press (p. 168)\n_START_SECTION_\nC\xc3\xb3digo em C++\n_START_PARAGRAPH_\ntemplate<class T>std::vector<T> counting_sort( const std::vector<T> &op ){_NEWLINE_   if ( op.empty() )_NEWLINE_      return std::vector<T> {};_NEWLINE__NEWLINE_   auto min = *std::min_element( op.begin(), op.end() );_NEWLINE_   auto max = *std::max_element( op.begin(), op.end() );_NEWLINE__NEWLINE_   std::vector<int> contagem( max - min + 1, 0 );_NEWLINE_   for ( auto it = op.begin(); it != op.end(); ++it )_NEWLINE_      ++contagem[ *it - min ];_NEWLINE__NEWLINE_   std::partial_sum( contagem.begin(), contagem.end(), contagem.begin() );_NEWLINE__NEWLINE_   std::vector<T> ordenado( op.size() );_NEWLINE_   for ( auto it2 = op.rbegin(); it2 != op.rend(); ++it2 )_NEWLINE_      ordenado[ --contagem[ *it2 - min ] ] = *it2;_NEWLINE__NEWLINE_   return ordenado;}\n_START_SECTION_\nC\xc3\xb3digo em C\n_START_PARAGRAPH_\n# include <stdio.h># include <string.h># include <stdlib.h># include <ctype.h># define MAX 100001struct data{_NEWLINE_    int number;_NEWLINE_    char key[100];} DataBase[MAX], VectorSort[MAX];int CounterNum[MAX];int size = 0;int main (void){_NEWLINE_    int i = 0;_NEWLINE__NEWLINE_    while (scanf("%d%s", &DataBase[size].number, DataBase[size].key) >= 1)_NEWLINE_        size++;_NEWLINE__NEWLINE_    int aux[2] = {0, 0};_NEWLINE_    for (i = 0; i <= size; i++)_NEWLINE_        aux[DataBase[i].number]++;_NEWLINE__NEWLINE_    aux[1] += aux[0];_NEWLINE__NEWLINE_    for (i = size - 1; i >= 0; i--)_NEWLINE_        VectorSort[--aux[DataBase[i].number]] = DataBase[i];_NEWLINE__NEWLINE_    for (i = 0; i < size; i++)_NEWLINE_        printf("Number: %d  ---  Key: %s\\n", VectorSort[i].number, VectorSort[i].key);_NEWLINE__NEWLINE_    return 0;}\n_START_SECTION_\nC\xc3\xb3digo em Java 1.0\n_START_PARAGRAPH_\n1 public Integer[] CountingSort(Integer[] v) { 2 _NEWLINE_ 3 //encontra o maior valor em v[] 4 int maior = v[0]; 5 for (int i = 1; i < v.length; i++) { 6 if (v[i] > maior) { 7 maior = v[i]; 8 } 9 }10 _NEWLINE_11 //conta quantas vezes cada valor de v[] aparece12 int[] c = new int[maior+1];//+1 pois se 10 for o maior valor, ele iria apenas de 0 a 913 for (int i = 0; i < v.length; i++) {14 c[v[i]] += 1;15 }16 _NEWLINE_17 //acumula as vezes de cada elemento de v[] com os elementos anteriores a este18 for (int i = 1; i < c.length; i++) {19 c[i] += c[i-1];20 }21 _NEWLINE_22 //adiciona os elementos em suas posi\xc3\xa7\xc3\xb5es conforme o acumulo de suas frequencias23 Integer[] b = new Integer[v.length];24 for (int i = b.length-1; i >= 0; i--) {//percorre do fim para o inicio para manter estavel, mas n\xc3\xa3o haveria problema em i = 0; i < b.lenght; i++25 b[c[v[i]] -1] = v[i];26 c[v[i]]--;27 }28 _NEWLINE_29 return b;30 }\n_START_SECTION_\nC\xc3\xb3digo em Java 1.1\n_START_PARAGRAPH_\npublic void CountingSort(Integer[] array, int leftIndex, int rightIndex) {_NEWLINE__NEWLINE_//Encontrar o maior valor _NEWLINE_int k = 0;_NEWLINE_for(int m = leftIndex; m < rightIndex; m++){_NEWLINE_if(array[m] > k){_NEWLINE_k = array[m];_NEWLINE_}_NEWLINE_}_NEWLINE__NEWLINE_//Cria vetor com o tamanho do maior elemento_NEWLINE_int[] vetorTemporario = new int[k];_NEWLINE__NEWLINE_//Inicializar com zero o vetor temporario_NEWLINE_for(int i = 0; i < vetorTemporario.length; i++){_NEWLINE_vetorTemporario[i] = 0;_NEWLINE_}_NEWLINE__NEWLINE_//Contagem das ocorrencias no vetor desordenado_NEWLINE_for(int j = leftIndex; j < rightIndex; j++){_NEWLINE_vetorTemporario[array[j]] += 1;_NEWLINE_}_NEWLINE__NEWLINE_//Fazendo o  complemento do numero anterior _NEWLINE_for(int i = leftIndex; i < k; i++){_NEWLINE_vetorTemporario[i] = vetorTemporario[i] + vetorTemporario[i - 1];_NEWLINE_}_NEWLINE__NEWLINE_//Ordenando o array da direita para a esquerda_NEWLINE_int[] vetorAuxiliar = new int[array.length];_NEWLINE_for(int j = rightIndex; j > leftIndex; j--) {_NEWLINE_vetorAuxiliar[vetorTemporario[array[j]]] = array[j];_NEWLINE_vetorTemporario[array[j]] -= 1; _NEWLINE_}_NEWLINE__NEWLINE_//Retornando os valores ordenados para o vetor de entrada_NEWLINE_for (int i = leftIndex; i < rightIndex; i++){_NEWLINE_array[i] = vetorAuxiliar[i];_NEWLINE_}_NEWLINE_}'