Clasificación de arreglos en Julia

El proceso de organizar los datos dados en un orden o manera particular depende de la salida. Es el almacenamiento de datos en orden ordenado. La clasificación se puede hacer de dos maneras, es decir, en orden ascendente y descendente. La clasificación se puede realizar utilizando un algoritmo de clasificación o funciones de clasificación. Entonces, al ordenar el programa, busque el número mínimo y cambie ese número al comienzo de la array o lista de acuerdo con el algoritmo.
Array juega un papel muy importante durante la clasificación. Se utilizan para almacenar la lista del elemento que debe ordenarse.
 

Técnicas de clasificación en Julia

Hay un total de 4 (Cuatro) algoritmos de clasificación en Julia, estos son:
 

• Tipo de inserción
• Ordenación rápida
• Clasificación rápida parcial (k)
• Ordenar por fusión

Tipo de inserción

Esta técnica de clasificación atraviesa la colección elemento a elemento, insertando cada elemento en su posición ordenada correcta en la lista de salida. 
InsertionSort es un algoritmo de ordenación estable O(n^2). Es eficiente para n muy pequeño y QuickSort lo usa internamente.
 

Ordenación rápida

QuickSort es muy rápido y se usa principalmente como un algoritmo de clasificación predeterminado, pero no es estable. Aquí estable significa «es decir, los elementos que se consideran iguales no permanecerán en el mismo orden en que aparecieron originalmente en la array que se va a ordenar». 
Y también, como se mencionó anteriormente, es el algoritmo predeterminado, pero solo para el valor numérico tanto flotante como entero.
Por otro lado, si hablamos de PartialQuickSort(K) es similar a QuickSort pero la única diferencia es que la array se ordena hasta K si K es un número entero o está en el rango de K.
Por ejemplo:
 

x = rand(1:500, 100)

así que primero creamos la array aleatoria de 100 elementos y la almacenamos en la x.
 

k = 50
k2 = 50:100

Entonces hemos asignado el valor de k, k2 
 

s = sort(x; alg=QuickSort)

Luego, aplicamos QuickSort y ordenamos la array x y puede ver el resultado anterior.
 

ps = sort(x; alg=PartialQuickSort(k))
qs = sort(x; alg=PartialQuickSort(k2))

Luego usamos PartialQuickSort con diferentes valores de k y ordenamos la array. Según el valor de k, primero ordenamos los primeros 50 valores de la array y luego, según el valor de k2, los últimos 50 valores de la array, como puede ver arriba.
 

combinarordenar

Ahora, si vemos este algoritmo de clasificación cuya complejidad está en O (n log n), que es un algoritmo de clasificación más estable. Pero necesita una array más que sea temporal y también que tenga la mitad del tamaño de la array dada/de entrada. MergeSort no es tan rápido como comparar con QuickSort. También es un algoritmo predeterminado para valores no numéricos.
Depende totalmente del programador qué algoritmo de clasificación quiere usar y puede cambiar según él / ella en la sintaxis.
==>El algoritmo predeterminado se elige sobre la base de que son rápidos y estables. Como se mencionó, QuickSort se selecciona porque es más rápido. La propiedad de estabilidad tiene un costo no despreciable, por lo que si no la necesita, es posible que desee especificar explícitamente su algoritmo preferido, 
 

sort!(v, alg=QuickSort)

==>El mecanismo por el cual Julia elige los algoritmos de clasificación predeterminados se implementa a través de la función Base.Sort.defalg(). Permite registrar un algoritmo particular como predeterminado en todas las funciones de clasificación para arrays específicas. Por ejemplo, estos son los dos métodos predeterminados de sort.jl:
 

defalg(v::AbstractArray) = MergeSort
defalg(v::AbstractArray{<:Number}) = QuickSort

==>En cuanto a las arrays numéricas, puede tener sentido elegir un algoritmo predeterminado no estable para los tipos de array para los que la noción de una ordenación estable no tiene sentido (es decir, cuando no se pueden distinguir dos valores que se comparan iguales).
 

Funciones utilizadas para ordenar

función ordenar()

Esta función devuelve una array ordenada o una copia ordenada de una array. Entendámoslo más claramente con la ayuda de un ejemplo:
Ejemplo 1: 
 

sort([2, 3, 1])

Producción: 
 

En el ejemplo anterior, podemos ver claramente que hemos pasado la array no ordenada en la función de ordenación y, a cambio, obtenemos la copia de la array ordenada.
Y también se puede ordenar una array a la inversa en Julia.
Ejemplo 2: 
 

sort([2, 3, 1], rev=true)

Producción: 
 

función sortperm()

Esta función también funciona como sort() pero en lugar de devolver la copia, devuelve una lista de índices que se pueden usar en la colección para producir una colección ordenada.
Ejemplo: 
 

r = rand(100:110, 10)
sortperm(r)

Comprendamos correctamente el ejemplo anterior, por lo que en el ejemplo anterior hay una función rand() que se usa para generar números aleatorios. Podemos pasar cualquier tipo de datos en la función rand.
Sintaxis: 
 

rand([rng=GLOBAL_RNG], [S], [dims...])

Luego, cuando pasamos la colección en sortperm(), podemos observar la primera salida donde se generan los índices y estos índices se pasan una vez más, como se muestra en el ejemplo, podemos obtener la salida deseada.
 

sortrows()

La clasificación lexicográfica se realiza en las filas de la array utilizando esta función. Veamos ejemplos de esto para entender: 
 

sortrows([7 3 5; -1 6 4; 9 -2 8])

Producción: 
 

3×3 Array{Int64, 2}:
 -1   6  4
  7   3  5
  9  -2  8

sortrows([7 3 5; -1 6 4; 9 -2 8], lt=(x, y)->isless(x[2], y[2]))

Producción: 
 

3×3 Array{Int64, 2}:
  9  -2  8
  7   3  5
 -1   6  4

sortrows([7 3 5; -1 6 4; 9 -2 8], rev=true)

Producción: 
 

3×3 Array{Int64, 2}:
  9  -2  8
  7   3  5
 -1   6  4

sortcols()

La clasificación lexicográfica se realiza en las filas de la array utilizando esta función.
Ejemplo:
 

sortcols([7 3 5; 6 -1 -4; 9 -2 8])

Producción: 
 

3×3 Array{Int64, 2}:
  3   5  7
 -1  -4  6
 -2   8  9

sortcols([7 3 5; 6 -1 -4; 9 -2 8],
         alg=InsertionSort, lt=(x, y)->isless(x[2], y[2]))

Producción: 
 

3×3 Array{Int64, 2}:
  5   3  7
 -4  -1  6
  8  -2  9

sortcols([7 3 5; 6 -1 -4; 9 -2 8], rev=true)

Producción: 
 

3×3 Array{Int64, 2}:
 7   5   3
 6  -4  -1
 9   8  -2

Ahora, la gran pregunta es qué pasa si alguien quiere definir su propia función mientras ordena la colección que no sea la función sort().
La respuesta a la afirmación anterior es que mediante el uso de las palabras clave ‘by’ y ‘lt’ .
 

Ordenar por y Comparar

Entonces, al usar las palabras clave ‘by’ y ‘lt’, uno puede proporcionar su propia función y también comparar los elementos durante la clasificación.
ordenar por: esta función procesa cada elemento antes de la comparación y proporciona una clave para ordenar.
Ejemplo: 
 

r = ["1E10", "150", "25", "3", "1.5", "1E-10", "0.5", ".999"];

Usando la ordenación predeterminada para el ejemplo anterior, ordenará la array en el orden en que aparece el carácter en Unicode.
 

sort(r)

Producción: 
 

Aparece “1E-10” después de “0.999”.
Para ordenar los números por su valor, pase la función parse() a by:
 

sort(r, by = x -> Meta.parse(x))

Producción: 
 

Las strings se ordenan ‘por’ su valor. La función by que proporciona produce la clave de clasificación numérica, pero los elementos de string originales aparecen en el resultado final.
También puede usar la función anónima mientras ordena.
Función ‘menor que’:
por defecto, isless() se usa al ordenar al comparar elementos. Pero, el primer elemento es menor que el segundo en una array ordenada.
La función ‘lt’ también se usa para cambiar el comportamiento al pasar las diferentes funciones que se pueden usar para comparar dos elementos y devolver verdadero si están ordenados.
Supongamos que queremos ordenar una array de palabras según el número de cada palabra.
Ejemplo , la palabra “naranja” se considerará “menor que” la palabra “limón”, porque tiene más vocales.
Primero necesitaremos una función que cuente las vocales:
 

vowelcount(string) = count(c -> (c in "aeiou"), lowercase(string))

Ahora puede pasar una función anónima a sort() que compara el recuento de vocales de dos elementos usando esta función y luego devuelve el elemento con un recuento más alto en cada caso:
 

sentence = split("Lorem ipsum dolor sit amet,
consectetur adipisicing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
 
sort(sentence, lt = (x, y) -> vowelcount(x) > vowelcount(y))

El resultado es que la palabra con más vocales aparece primero:
 

La función sort() también le permite especificar una ordenación inversa: después de que las funciones ‘by’ y ‘lt’ (si se usan) hayan hecho su trabajo, un valor verdadero pasado a rev invierte el resultado.
 

Clasificación de arrays 2-D

Usando sortslices() podemos ordenar una array multidimensional en Julia.
Por ejemplo: 
 

table = ["F" "B" "I"; "A" "D" "G"; "H" "C" "E"]

Producción: 
 

3×3 Array{String, 2}:
 "F"  "B"  "I"
 "A"  "D"  "G"
 "H"  "C"  "E"

Proporciona un número o una tupla a la palabra clave dims («dimensiones») que indica lo que desea ordenar. Para ordenar la tabla de modo que se ordene la primera columna, use 1:
 

sortslices(table, dims=1)

Producción: 
 

3×3 Array{String, 2}:
 "A"  "D"  "G"
 "F"  "B"  "I"
 "H"  "C"  "E"

Tenga en cuenta que sortslices devuelve una nueva array. La primera columna está en orden alfabético.
Use dims=2 para ordenar la tabla de modo que se ordene la primera fila:
 

sortslices(table, dims=2)

Producción: 
 

3×3 Array{String, 2}:
 "B"  "F"  "I"
 "D"  "A"  "G"
 "C"  "H"  "E"

Ahora la primera fila está en orden alfabético. 
 

Si desea ordenar por algo que no sea el primer elemento, pase una función a por. Entonces, para ordenar las filas de modo que la columna del medio esté en orden alfabético, use:
 

sortslices(table, dims=1, by = x -> x[2])

Producción: 
 

3×3 Array{String, 2}:
 "F"  "B"  "I"
 "H"  "C"  "E"
 "A"  "D"  "G"