Introduzione all'ordinamento in R

L'ordinamento è uno degli aspetti cruciali dell'analisi dei dati. È una tecnica in cui i dati sono organizzati o separati in un ordine specifico. I dati vengono ordinati per estrarre le informazioni richieste dal set di dati. Ad esempio, disponendo i dati in ordine crescente in base alla chiave della data, qui sono stati specificati i criteri per ordinare. Questa operazione può essere facilmente eseguita usando il linguaggio R. Nel linguaggio R ci sono più funzioni di ordinamento come ordinamento a bolle e ordinamento per selezione. In questo articolo vedremo l'importanza delle diverse funzioni di ordinamento e spiegheremo ognuna di esse con esempi.

Ordinamento eseguito in R

Esistono diversi modi in cui i dati possono essere ordinati in R. Spetta all'analista dei dati considerare il metodo più adatto in base alla struttura dei dati. Il linguaggio R ha molteplici funzioni e modi per ordinare i dati come il pacchetto sort (), order () e dplyrI ().

Cose da tenere a mente prima di ordinare i dati.

  1. Ordine in cui i dati devono essere ordinati in ordine crescente o decrescente.
  2. Criteri di ordinamento per più colonne.
  3. Contabilità mancante e valori duplicati durante l'ordinamento. Spetta all'analista decidere cosa deve essere fatto con i valori mancanti e duplicati. Prima di rimuovere o sostituire valori nulli, è necessario considerare l'impatto complessivo sui dati.

Funzione Sort () in R

La funzione di ordinamento in R viene utilizzata per ordinare un vettore. Per impostazione predefinita, il valore è organizzato in ordine crescente. Facciamo un esempio della colonna del segno di tutti gli studenti in una classe.

La sintassi per ordinare il vettore è

“sort (x, decreasing = FALSE)”

Qui x si riferisce al vettore e la riduzione deve essere sostituita da VERO quando l'ordinamento deve essere eseguito in ordine decrescente. La funzione di ordinamento viene utilizzata per disporre il vettore numerico o dei caratteri nell'ordine desiderato. La principale limitazione della funzione di ordinamento è che non può essere utilizzata per ordinare un frame di dati. Per superare questa limitazione, viene utilizzata la funzione Order ().

Un esempio di ordinamento di base che utilizza la funzione sort ()

set.seed(1)
x <- sample(1:100, 10)
x

Produzione
(1) 68 39 1 34 87 43 14 82 59 51

sort (x)

Produzione

(1) 1 14 34 39 43 51 59 68 82 87

L'ordinamento dei frame di dati può essere realizzato con l'aiuto della funzione order (). Le variabili possono essere facilmente ordinate in ordine crescente o decrescente, tuttavia per impostazione predefinita la funzione ordine ordinerà la variabile in ordine crescente.

> 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

Si noti che il segno negativo viene utilizzato davanti alla colonna Età (-df $ Età) per ordinare l'Età in ordine decrescente. In alternativa, l'argomento discendente può essere utilizzato in questa posizione. La funzione Ordine viene utilizzata per fare riferimento all'indice di colonna anziché al nome della colonna. Ad esempio al posto dell'età il riferimento indice del frame di dati che sarebbe "1". Tenendo presente che i valori dell'indice iniziano con uno "0".

In alcuni casi, potrebbe essere necessario ordinare i dati con più criteri, questo può essere ottenuto in R con l'aiuto dell'uso di nomi di variabili o numeri di indice. Nell'esempio seguente ho usato il set di dati mtcars che è disponibile in 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) ), )

In R, un modo alternativo per ordinare i dati è usando il pacchetto dplyr. Questo pacchetto è molto facile da usare e affidabile con istruzioni precise disponibili.

> install.packages("dplyr")
> library(dplyr)
> df <- mtcars
>
> # sort the dataframe by key disp
> arrange(mydata, disp)

Tipi di ordinamento in R

R è dotato di algoritmi multipli per eseguire l'ordinamento sui dati. Di seguito sono riportati i diversi tipi di funzione di ordinamento. Per illustrare i diversi tipi di ordinamento, viene utilizzato un campione di 10 numeri casuali da un array.

1. Bubble Sort

In questo algoritmo, due valori vengono confrontati fianco a fianco e gli elementi scambiano la loro posizione quando vengono soddisfatti i criteri. Può essere crescente o in ordine decrescente. Nella bolla si formano coppie per gli elementi disponibili in variabili e gli elementi vengono confrontati l'uno con l'altro, quando un elemento è maggiore di un altro si scambiano. Il processo si ripete fino all'ultimo 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

Produzione

2. Ordinamento inserzione

Nell'algoritmo di ordinamento per inserzione, gli elementi ordinati e non ordinati vengono confrontati e l'elemento non ordinato viene posizionato in un posto adatto dopo ogni iterazione.

In questo algoritmo si presume che il primo elemento sia ordinato e il secondo elemento sia memorizzato separatamente come elemento chiave. L'elemento ordinato viene quindi confrontato con la chiave. Se l'elemento ordinato è maggiore dell'elemento chiave, i posti vengono scambiati e l'elemento chiave è il primo 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

Produzione

3. Selezione ordinamento

La funzione di ordinamento per selezione è un algoritmo di ordinamento ampiamente utilizzato nel linguaggio R. In questo tipo di ordinamento, l'elemento più piccolo dall'elenco non ordinato viene spostato all'inizio dell'elenco. Nell'algoritmo di ordinamento della selezione, l'elemento più piccolo dall'array dell'elenco non ordinato viene selezionato e posizionato all'inizio dell'elenco non ordinato ad ogni iterazione. Ad esempio, in una riga di numeri disposti in una sequenza casuale l'elemento iniziale o il numero è selezionato come minimo. Nel passaggio successivo, il numero minimo selezionato viene confrontato con l'elemento o il numero successivo. Nel caso in cui l'elemento confrontato sia più piccolo del nostro minimo selezionato, il secondo elemento diventa il minimo. Questo processo è ripetuto fino all'ultimo 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

Produzione

4. Ordinamento rapido

L'algoritmo Quicksort funziona come divisione e regola. L'elemento casuale viene selezionato come perno in una matrice e quindi tutti gli altri elementi tranne pivot sono divisi in due partizioni. Nel passaggio successivo, tutti gli elementi che sono inferiori e maggiori del perno sono divisi in due diverse partizioni. Infine, gli elementi vengono ordinati usando la ricorsione.

> # 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

Produzione

5. Unisci ordinamento

Unisci ordinamento è molto simile a quicksort, tuttavia qui l'array è diviso in due metà uguali. L'algoritmo Unisci ordinamento è stato diviso in due parti: una fusione e una funzione di classificazione. Nell'ordinamento unito, un elenco viene suddiviso in più elenchi secondari fino a quando ciascun elenco secondario è costituito da un singolo elemento. L'unione dei risultati di questi elenchi secondari è un elenco ordinato.

> 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

Produzione

6. HeapSort

La tecnica Heap Sort è molto simile a quella dell'ordinamento di selezione in cui l'elemento più piccolo da un elenco non ordinato è selezionato in ogni iterazione e si colloca all'inizio dell'elenco. Tuttavia, la tecnica heapsort utilizza concetti di alberi.

> 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

Produzione

Conclusione

In questo articolo, abbiamo visto diversi modi in cui i dati possono essere ordinati usando R. Abbiamo visto come viene utilizzato il comando di ordinamento e ordinamento per ordinare un frame di dati, nell'articolo sono stati mostrati ulteriori limiti della funzione di ordinamento rispetto alla funzione di ordinamento. È stata discussa a fondo una spiegazione dettagliata di diversi algoritmi di ordinamento come ordinamento a bolle, ordinamento per selezione e ordinamento per fusione. Essendo l'ordinamento uno dei passaggi più importanti dell'analisi dei dati, hanno diverse funzioni per molteplici esigenze. Spetta interamente al tecnico dei dati scegliere il metodo più appropriato per l'ordinamento in base ai dati disponibili.

Articoli consigliati

Questa è stata una guida per l'ordinamento in R. Qui discutiamo di ciò che è l'ordinamento in R, caratteristiche e tipi di ordinamento in R. Puoi anche consultare gli altri articoli suggeriti per saperne di più -

  1. Lingue per la scienza dei dati
  2. Database in SQL
  3. Tipi di dati in C
  4. Tipi di dati PostgreSQL
  5. Introduzione all'ordinamento nel tableau
  6. Inserimento Ordina in JavaScript
  7. Guida completa all'ordinamento in C # con esempi
  8. Funzione di ordinamento in Python con esempi

Categoria:

Big Data