Introducción a la clasificación en R
La clasificación es uno de los aspectos cruciales del análisis de datos. Es una técnica en la que los datos se organizan o segregan en un orden específico. Los datos se ordenan para extraer la información requerida del conjunto de datos. Por ejemplo, organizando los datos en orden ascendente según la clave de fecha, aquí se han especificado los criterios para ordenarlos. Esta operación se puede realizar fácilmente utilizando el lenguaje R. En el lenguaje R, existen múltiples funciones de clasificación, como la clasificación de burbujas y la selección. En este artículo, veremos la importancia de diferentes funciones de clasificación y explicaremos cada una de ellas con ejemplos.
Clasificación realizada en R
Existen múltiples formas de ordenar los datos en R. Depende del analista de datos considerar el método más adecuado en función de la estructura de los datos. El lenguaje R tiene múltiples funciones y formas de ordenar los datos, como el paquete sort (), order () y dplyrI ().
Cosas a tener en cuenta antes de ordenar los datos.
- Orden en el que los datos deben ordenarse de forma ascendente o descendente.
- Múltiples criterios de clasificación de columnas.
- Contabilidad faltante y valores duplicados durante la clasificación. Depende del analista decidir qué se debe hacer con los valores faltantes y duplicados. Antes de eliminar o reemplazar valores nulos, se debe considerar el impacto general en los datos.
Función Sort () en R
La función Ordenar en R se usa para ordenar un vector. Por defecto, el valor está organizado en orden ascendente. Tomemos un ejemplo de la columna de la marca de todos los estudiantes en un salón de clases.
La sintaxis para ordenar el vector es
“sort (x, decreasing = FALSE)”
Aquí x se refiere al vector y la disminución tiene que reemplazarse a VERDADERO cuando la clasificación debe hacerse en orden descendente. La función de clasificación se utiliza para organizar el vector numérico o de caracteres en el orden deseado. La principal limitación de la función de clasificación es que no se puede usar para ordenar un marco de datos. Para superar esta limitación, se utiliza la función Order ().
Un ejemplo básico de ordenación utilizando la función sort ()
set.seed(1)
x <- sample(1:100, 10)
x
Salida
(1) 68 39 1 34 87 43 14 82 59 51
ordenar (x)
Salida
(1) 1 14 34 39 43 51 59 68 82 87La ordenación de marcos de datos se puede lograr con la ayuda de la función order (). Las variables se pueden ordenar fácilmente en orden ascendente o descendente, sin embargo, la función de orden ordenará la variable en forma ascendente de forma predeterminada.
> df <- data.frame("Serial_number" = 1:5, "Age" = c(20, 21, 17, 18, 19), "Name" = c("Johnny", "Dorian", "Linda", "Cathy", "Rick"))
>
> # Sort by age ascending order
> newdataAsc newdataAsc
# sorting is descending order
> newdataDsc> newdataDsc newdataAsc
Tenga en cuenta que el signo negativo se usa delante de la columna Edad (-df $ Edad) para ordenar la Edad en orden descendente. Alternativamente, el argumento descendente puede usarse en esta posición. La función Orden se usa para referirse al índice de la columna en lugar del nombre de la columna. Por ejemplo, en lugar de la edad, el índice de referencia del marco de datos que sería "1". Teniendo en cuenta los valores del índice comienza un "0".
En algunos casos, es posible que necesitemos ordenar los datos con múltiples criterios, esto se puede lograr en R con la ayuda del uso de nombres de variables o números de índice. En el siguiente ejemplo, he usado el conjunto de datos mtcars que está disponible en R studio.
df <- mtcars
> df
> # sort the dataframe by key disp
> df(with(df, order(mpg, disp)), )
> # Sort by column index values
> df(order( df(, 1), df(, 3) ), )
En R, una forma alternativa de ordenar los datos es mediante el uso del paquete dplyr. Este paquete es muy fácil de usar y confiable con instrucciones precisas disponibles.
> install.packages("dplyr")
> library(dplyr)
> df <- mtcars
>
> # sort the dataframe by key disp
> arrange(mydata, disp)
Tipos de clasificación en R
R está equipado con múltiples algoritmos para realizar la clasificación de los datos. A continuación se muestran los diferentes tipos de función de clasificación. Para ilustrar los diferentes tipos de clasificación, se utiliza una muestra de 10 números aleatorios de una matriz.
1. Ordenar burbujas
En este algoritmo, se comparan dos valores uno al lado del otro y los elementos intercambian su posición cuando se cumplen los criterios. Puede ser ascendente o descendente. En la clasificación de burbujas, los pares se forman para los elementos disponibles en variable y los elementos se comparan entre sí, cuando un elemento es mayor que otro se intercambian. El proceso se repite hasta el último elemento.
> bubble_sort <- function (x, ascending = TRUE) (
+ n <- length(x)
+ if (ascending) (
+ for(i in 1:(n-1))(
+ for(j in 1:(ni)) (
+ if(x(j+1) < x(j)) (
+ tmp <- x (j) + x(j) <- x( j+ 1) + x(j+1) <- tmp
+ )
+ )
+ )
+ )
+ else (
+ for(i in 1:(n-1))(
+ for(j in 1:(ni)) (
+ if(x(j+1) > x(j)) (
+ tmp <- x (j) + x(j) <- x( j+ 1) + x(j+1) <- tmp
+ )
+ )
+ )
+ )
+ x
+ )
>
> x <-sample(1:100, 10)
> example <- bubble_sort(x)
> example
Salida
2. Ordenar por inserción
En el algoritmo de clasificación por inserción, se comparan los elementos ordenados y sin clasificar, y el elemento sin clasificar se coloca en un lugar adecuado después de cada iteración.
En este algoritmo se supone que el primer elemento está ordenado y el segundo elemento se almacena por separado como elemento clave. El elemento ordenado se compara con la clave. Si el elemento ordenado es mayor que el elemento clave, los lugares se intercambian y el elemento clave es el primer elemento.
> insertion_sort <- function(A)(
+ for (j in 2:length(A)) (
+ key = A(j) + i = j - 1
+ while (i > 0 && A(i) > key) (
+ A((i + 1)) = A(i) + i = i - 1
+ )
+ A((i + 1)) = key
+ )
+ A
+ )
>
>
> # testing the insertion function
> x <-sample(1:100, 10)
> example <- insertion_sort(x)
> example
Salida
3. Selección de selección
La función de clasificación de selección es un algoritmo de clasificación ampliamente utilizado en el lenguaje R. En este tipo de clasificación, el elemento más pequeño de la lista no ordenada se empuja al comienzo de la lista. En el algoritmo de ordenamiento por selección, el elemento más pequeño de la matriz de la lista sin clasificar se selecciona y se coloca al comienzo de la lista sin clasificar en cada iteración. Por ejemplo, en una fila de números dispuestos en una secuencia aleatoria, el elemento inicial o número se selecciona como mínimo. En el siguiente paso, el número mínimo seleccionado se compara con el siguiente elemento o número. En caso de que el elemento comparado sea más pequeño que nuestro mínimo seleccionado, el segundo elemento se convierte en el mínimo. Este proceso se repite hasta el último elemento.
> selection_sort <- function (x, ascending = TRUE) (
+ max <- length(x)
+ if (ascending) (
+ for (j in 1:(max-1))(
+ m <- x(j) + p <- j
+ for(k in (j+1):max) (
+ if(x(k) < m) (
+ m <- x(k) + p <- k
+ ) ## end if
+ ) ## end for k
+ x(p) <- x(j) + x(j) <- m
+ ) ## end for j
+ ) ## end ascending if
+ else (
+ for (j in 1:(max-1))(
+ m <- x(j) + p <- j
+ for(k in (j+1):max) (
+ if(x(k) > m) (
+ m <- x(k) + p <- k
+ ) ## end if
+ ) ## end for k
+ x(p) <- x(j) + x(j) <- m
+ ) ## end for j
+ ) ## end ascending else
+ x
+ )
>
>
> # testing the selectionsort function
> x <-sample(1:100, 10)
>
> example <- selection_sort(x)
> example
Salida
4. Clasificación rápida
El algoritmo Quicksort funciona como divide y vencerás. El elemento aleatorio se selecciona como un pivote en una matriz y luego todos los demás elementos, excepto el pivote, se dividen en dos particiones. En el siguiente paso, todos los elementos que son menores y mayores que el pivote se dividen en dos particiones diferentes. Finalmente, los elementos se ordenan usando recursividad.
> # Quick sort algorithm:
> quickSort <- function(arr) (
+ # Pick a number at random.
+ mid <- sample(arr, 1)
+
+ # Place-holders for left and right values.
+ left <- c()
+ right <- c()
+
+ # Move all the smaller values to the left, bigger values to the right.
+ lapply(arr(arr != mid), function(d) (
+ if (d < mid) (
+ left <<- c(left, d)
+ )
+ else (
+ right <<- c(right, d)
+ )
+ ))
+
+ if (length(left) > 1) (
+ left <- quickSort(left)
+ )
+
+ if (length(right) > 1) (
+ right <- quickSort(right)
+ )
+
+ # Finally, return the sorted values.
+ c(left, mid, right)
+ )
>
> x <-sample(1:100, 10)
>
> RES <- quickSort(x)
> RES
Salida
5. Combinar Ordenar
La ordenación por fusión es muy similar a la ordenación rápida, sin embargo, aquí la matriz se divide en dos mitades iguales. El algoritmo de clasificación de fusión se ha dividido en dos partes: una función de fusión y una de clasificación. En el orden de fusión, una lista se divide en varias sublistas hasta que cada sublista consista en un elemento individual. Fusionar los resultados de las sublistas es una lista ordenada.
> mmerge<-function(a, b) (
+ r<-numeric(length(a)+length(b))
+ ai<-1; bi<-1; j<-1;
+ for(j in 1:length(r)) (
+ if((ai<=length(a) && a(ai)length(b)) (
+ r(j) <- a(ai) + ai <- ai+1
+ ) else (
+ r(j) <- b(bi) + bi <- bi+1
+ )
+ )
+ r
+ )
> mmergesort<-function(A) (
+ if(length(A)>1) (
+ q <- ceiling(length(A)/2)
+ a <- mmergesort(A(1:q))
+ b <- mmergesort(A((q+1):length(A)))
+ mmerge(a, b)
+ ) else (
+ A
+ )
+ )
>
> x <-sample(1:100, 10)
>
> RES <- mmergesort(x)
> RES
Salida
6. HeapSort
La técnica de clasificación de montón es muy similar a la de clasificación de selección donde el elemento más pequeño de una lista sin clasificar se selecciona en cada iteración y se coloca al comienzo de la lista. Sin embargo, la técnica del montón utiliza conceptos de árbol.
> heap.structure<-function(vect)
+ (
+ le=length(vect)
+ heap=vec
+ for (k in le:1)
+ (
+ heap=modify_heap(heap, k)
+ )
+ return(heap)
+ )
>
>
> modify_heap<-function(heap, rooti)
+ (
+ le=length(heap)
+ flag=0
+
+ while (rooti*2 <= le && flag==1)
+ (
+ left.i=rooti*2
+ right.i=rooti*2+2
+ flag=1
+ child=c(heap(left.i), heap(right.i))
+ child=child(!is.na(child)) + min.ind=which.min(child)
+ if (heap(rooti)>child(min.ind))
+ (
+ flag=1
+ heap.ind=c(left.i, right.i)(min.ind) +
+ tmp1=heap(heap.ind) + heap(heap.ind)=heap(rooti) + heap(rooti)=tmp1
+
+ rooti=heap.ind
+ )
+ )
+ return(heap)
+ )
>
> heap_sort<-function(heap)
+ (
+ sorted.heap=NULL
+ le=length(heap)
+ while(le>0)
+ (
+ sorted.heap=c(sorted.heap, heap(1))
+ le=length(heap)
+ heap(1)=heap(le) + heap=heap(1:(le-1)) + heap=modify_heap(heap, rooti=1)
+ le=le-1
+ )
+ return(sorted.heap)
+ )
>
>
> x <- sample(1:100, 10)
> heap=heap.building(x)
> heap_sort=heap_sort(heap)
> heap_sort
Salida
Conclusión
En este artículo, hemos visto diferentes formas en que los datos se pueden ordenar usando R. Hemos visto cómo se usa el comando ordenar y ordenar para ordenar un marco de datos, en el artículo se muestran otras limitaciones de la función de ordenar sobre la función de orden. Se ha discutido a fondo una explicación detallada de los diferentes algoritmos de ordenamiento, como el ordenamiento por burbuja, el ordenamiento por selección y el ordenamiento por fusión. Siendo uno de los pasos más importantes del análisis de datos, la clasificación tiene diferentes funciones para múltiples necesidades. Corresponde totalmente al ingeniero de datos elegir el método más apropiado para ordenar según los datos disponibles.
Artículos recomendados
Esta ha sido una guía para la Clasificación en R. Aquí discutimos qué es la clasificación en R, las características y los tipos de clasificación en R. También puede consultar nuestros otros artículos sugeridos para obtener más información:
- Lenguajes de ciencia de datos
- Base de datos en SQL
- Tipos de datos en C
- Tipos de datos PostgreSQL
- Introducción a la clasificación en Tableau
- Inserción Ordenar en JavaScript
- Guía completa para ordenar en C # con ejemplos
- Función de clasificación en Python con ejemplos