in

Clasificación de cubos – GeeksforGeeks

gfg 200x200 min

La clasificación por cubos es principalmente útil cuando la entrada se distribuye uniformemente en un rango. Por ejemplo, considere el siguiente problema.
Ordene un gran conjunto de números de punto flotante que estén en el rango de 0.0 a 1.0 y estén distribuidos uniformemente en todo el rango. ¿Cómo ordenamos los números de manera eficiente?
Una forma sencilla es aplicar un algoritmo de clasificación basado en comparación. El límite inferior para el algoritmo de clasificación basado en comparación (clasificación por combinación, clasificación en pila, clasificación rápida, etc.) es Ω (n Log n), es decir, no pueden hacerlo mejor que nLogn.
¿Podemos ordenar la matriz en tiempo lineal? El ordenamiento por recuento no se puede aplicar aquí ya que usamos claves como índice en el ordenamiento por recuento. Aquí las claves son números de coma flotante.
La idea es utilizar la clasificación de cubos. A continuación se muestra el algoritmo de cubeta.

bucketSort(arr[], n)
1) Create n empty buckets (Or lists).
2) Do following for every array element arr[i].
.......a) Insert arr[i] into bucket[n*array[i]]
3) Sort individual buckets using insertion sort.
4) Concatenate all sorted buckets.

BucketSort

Complejidad del tiempo: Si asumimos que la inserción en un cubo toma O (1) tiempo, entonces los pasos 1 y 2 del algoritmo anterior claramente toman O (n) tiempo. El O (1) es fácilmente posible si usamos una lista vinculada para representar un cubo (en el siguiente código, el vector C ++ se usa para simplificar). El paso 4 también lleva O (n) tiempo, ya que habrá n elementos en todos los depósitos.
El paso principal para analizar es el paso 3. Este paso también toma O (n) tiempo en promedio si todos los números están distribuidos uniformemente (consulte Libro CLRS para más detalles)
A continuación se muestra la implementación del algoritmo anterior.

C ++

#include <algorithm>

#include <iostream>

#include <vector>

using namespace std;

void bucketSort(float arr[], int n)

{

    

    

    vector<float> b[n];

    

    

    for (int i = 0; i < n; i++) {

        int bi = n * arr[i];

        b[bi].push_back(arr[i]);

    }

    

    for (int i = 0; i < n; i++)

        sort(b[i].begin(), b[i].end());

    

    int index = 0;

    for (int i = 0; i < n; i++)

        for (int j = 0; j < b[i].size(); j++)

            arr[index++] = b[i][j];

}

int main()

{

    float arr[]

        = { 0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434 };

    int n = sizeof(arr) / sizeof(arr[0]);

    bucketSort(arr, n);

    cout << "Sorted array is n";

    for (int i = 0; i < n; i++)

        cout << arr[i] << " ";

    return 0;

}

Java

import java.util.*;

import java.util.Collections;

class GFG {

    

    

    static void bucketSort(float arr[], int n)

    {

        if (n <= 0)

            return;

        

        @SuppressWarnings("unchecked")

        Vector<Float>[] buckets = new Vector[n];

        for (int i = 0; i < n; i++) {

            buckets[i] = new Vector<Float>();

        }

        

        for (int i = 0; i < n; i++) {

            float idx = arr[i] * n;

            cubos[(int)idx].add (arr[i]);

        }

        

        for (int i = 0; i < n; i++) {

            Collections.sort(buckets[i]);

        }

        

        int index = 0;

        for (int i = 0; i < n; i++) {

            for (int j = 0; j < buckets[i].size(); j++) {

                arr[index++] = buckets[i].get(j);

            }

        }

    }

    

    public static void main(String args[])

    {

        float arr[] = { (float)0.897, (float)0.565,

                        (float)0.656, (float)0.1234,

                        (float)0.665, (float)0.3434 };

        int n = arr.length;

        bucketSort(arr, n);

        System.out.println("Sorted array is ");

        for (float el : arr) {

            System.out.print(el + " ");

        }

    }

}

Python3

def insertionSort(b):

    for i in range(1, len(b)):

        up = b[i]

        j = i - 1

        while j >= 0 and b[j] > up:

            B[j + 1] = b[j]

            j -= 1

        B[j + 1] = up    

    return b    

            

def bucketSort(x):

    arr = []

    slot_num = 10

                  

    for i in range(slot_num):

        arr.append([])

        

    

    for j in x:

        index_b = int(slot_num * j)

        arr[index_b].append(j)

    

    

    for i in range(slot_num):

        arr[i] = insertionSort(arr[i])

        

    

    k = 0

    for i in range(slot_num):

        for j in range(len(arr[i])):

            x[k] = arr[i][j]

            k += 1

    return x

x = [0.897, 0.565, 0.656,

     0.1234, 0.665, 0.3434]

print("Sorted Array is")

print(bucketSort(x))

C#

using System;

using System.Collections;

using System.Collections.Generic;

class GFG {

  

  

  static void bucketSort(float []arr, int n)

  {

    if (n <= 0)

      return;

    

    List<float>[] buckets = new List<float>[n];

    for (int i = 0; i < n; i++) {

      buckets[i] = new List<float>();

    }

    

    for (int i = 0; i < n; i++) {

      float idx = arr[i] * n;

      cubos[(int)idx].Añadir (arr[i]);

    }

    

    for (int i = 0; i < n; i++) {

      buckets[i].Sort();

    }

    

    int index = 0;

    for (int i = 0; i < n; i++) {

      for (int j = 0; j < buckets[i].Count; j++) {

        arr[index++] = buckets[i][j];

      }

    }

  }

  

  public static void Main()

  {

    float []arr = { (float)0.897, (float)0.565,

                   (float)0.656, (float)0.1234,

                   (float)0.665, (float)0.3434 };

    int n = arr.Length;

    bucketSort(arr, n);

    Console.WriteLine("Sorted array is ");

    foreach(float el in arr) {

      Console.Write(el + " ");

    }

  }

}

Javascript

<script>

function bucketSort(arr,n)

{

    if (n <= 0)

            return;

 

        

        let buckets = new Array(n);

 

        for (let i = 0; i < n; i++)

        {

            buckets[i] = [];

        }

 

        

        for (let i = 0; i < n; i++) {

            let idx = arr[i] * n;

            buckets[Math.floor(idx)].push(arr[i]);

        }

 

        

        for (let i = 0; i < n; i++) {

            buckets[i].sort(function(a,b){return a-b;});

        }

 

        

        let index = 0;

        for (let i = 0; i < n; i++) {

            for (let j = 0; j < buckets[i].length; j++) {

                arr[index++] = buckets[i][j];

            }

        }

}

deja arr = [0.897, 0.565,

         0.656, 0.1234,

         0.665, 0.3434];

let n = arr.length;

bucketSort(arr, n);

document.write("Sorted array is <br>");

for (let el of arr.values()) {

    document.write(el + " ");

}

</script>

Producción
Sorted array is 
0.1234 0.3434 0.565 0.656 0.665 0.897 

Clasificación de cubo para números que tienen una parte entera:

Algoritmo :

  1. Encuentra el elemento máximo y el mínimo de la matriz.
  2. Calcule el rango de cada cubo
          range = (max - min) / n
          n is the number of buckets

3. Cree n depósitos de rango calculado

4. Distribuya los elementos de la matriz en estos depósitos.

          BucketIndex = ( arr[i] - min ) / range

6. Ahora clasifique cada cubo de forma individual

7. Reúna los elementos ordenados de los depósitos a la matriz original.

Input :    
Unsorted array:  [ 9.8 , 0.6 , 10.1 , 1.9 , 3.07 , 3.04 , 5.0 , 8.0 , 4.8 , 7.68 ]
No of buckets :  5

Output :  
Sorted array:   [ 0.6 , 1.9 , 3.04 , 3.07 , 4.8 , 5.0 , 7.68 , 8.0 , 9.8 , 10.1 ]

bucketSort

Input :    
Unsorted array:  [0.49 , 5.9 , 3.4 , 1.11 , 4.5 , 6.6 , 2.0]
No of buckets: 3

Output :  
Sorted array:   [0.49 , 1.11 , 2.0 , 3.4 , 4.5 , 5.9 , 6.6]

Codigo:

Python3

def bucketSort(arr, noOfBuckets):

    max_ele = max(arr)

    min_ele = min(arr)

    

    rnge = (max_ele - min_ele) / noOfBuckets

    temp = []

    

    for i in range(noOfBuckets):

        temp.append([])

    

    

    for i in range(len(arr)):

        diff = (arr[i] - min_ele) / rnge -

              int((arr[i] - min_ele) / rnge)

        

        if(diff == 0 and arr[i] != min_ele):

            temperatura[int((arr[i] - min_ele) / rnge) - 1].append(arr[i])

        else:

            temperatura[int((arr[i] - min_ele) / rnge)].append(arr[i])

    

    for i in range(len(temp)):

        if len(temp[i]) != 0:

            temp[i].sort()

    

    

    k = 0

    for lst in temp:

        if lst:

            for i in lst:

                arr[k] = i

                k = k+1

arr = [9.8, 0.6, 10.1, 1.9, 3.07, 3.04, 5.0, 8.0, 4.8, 7.68]

noOfBuckets = 5

bucketSort(arr, noOfBuckets)

print("Sorted array: ", arr)

Producción
Sorted array:  [0.6, 1.9, 3.04, 3.07, 4.8, 5.0, 7.68, 8.0, 9.8, 10.1]

Clasificación de depósito para clasificar una matriz con números negativos
Referencias:
Introducción a los algoritmos 3ra edición por Clifford Stein, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest
http://en.wikipedia.org/wiki/Bucket_sort

https://youtu.be/VuXbEb5ywrU
Instantáneas:

scene00505escena01009escena01513escena01729scene01801scene01945escena02017escena02521

Otros algoritmos de clasificación en GeeksforGeeks / GeeksQuiz:

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema discutido anteriormente.

¡Atención lector! No dejes de aprender ahora. Obtenga todos los conceptos importantes de DSA con el Curso autodidacta de DSA a un precio asequible para los estudiantes y prepárese para la industria. Para completar su preparación desde el aprendizaje de un idioma hasta DS Algo y muchos más, consulte Curso completo de preparación para entrevistas.

En caso de que desee asistir clases en vivo con expertos, consulte Clases en vivo de DSA para profesionales que trabajan y Programación competitiva en vivo para estudiantes.

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

apple touch icon@2

Convierta un formato de fecha en otro en PHP

150px Astringent

Astringente vs tóner: diferencia y comparación