Sorterer i R - Funksjoner og typer sortering i R med samplingskoder

• Introduksjon til sortering i R

Introduksjon til sortering i R

Sortering er en av de avgjørende aspektene ved dataanalyse. Det er en teknikk der dataene er ordnet eller segregerte i en bestemt rekkefølge. Data sorteres for å trekke ut den nødvendige informasjonen fra datasettet. For eksempel å ordne dataene i stigende rekkefølge basert på datatasten, her er kriterier spesifisert for å sortere. Denne operasjonen kan enkelt utføres ved bruk av R-språket. På R-språk er det flere sorteringsfunksjoner som boble sortering og valg sortering. I denne artikkelen vil vi se viktigheten av forskjellige sorteringsfunksjoner og forklare hver av dem med eksempler.

Sortering utført i R

Det er flere måter data kan sorteres i R. Det er opp til dataanalytikeren å vurdere den mest passende metoden basert på strukturen til dataene. R-språk har flere funksjoner og måter å sortere dataene, for eksempel sortering (), rekkefølge () og dplyrI () -pakke.

Ting du må huske på før du sorterer dataene.

1. Ordre i hvilken data må sorteres stigende eller synkende.
2. Flere kolonner sorteringskriterier.
3. Regnskap mangler og dupliserte verdier under sortering. Det er opp til analytikeren å bestemme hva som må gjøres med de manglende verdiene og duplikatverdiene. Før du fjerner eller erstatter nullverdier, bør den samlede innvirkningen på dataene vurderes.

Sorter () -funksjonen i R

Sorteringsfunksjon i R brukes til å sortere en vektor. Som standard er verdien organisert i stigende rekkefølge. La oss ta et eksempel på merkesøylen til alle elevene i et klasserom.

Syntaks for å sortere vektoren er

“sort (x, decreasing = FALSE)”

Her refererer x til vektoren og avtagende må erstattes til SANN når sorteringen må gjøres i synkende rekkefølge. Sorteringsfunksjonen brukes til å arrangere numerisk eller tegnvektor i ønsket rekkefølge. Hovedbegrensningen for sorteringsfunksjonen er at den ikke kan brukes til å sortere en dataramme. For å overvinne denne begrensningen brukes Order () -funksjonen.

Et grunnleggende sorteringseksempel ved bruk av funksjonen sortering ()

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

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

sort (x)

Produksjon

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

Sortering av datarammer kan oppnås ved hjelp av ordre () -funksjon. Variabler kan enkelt sorteres i enten stigende eller synkende rekkefølge. Ordrefunksjonen vil imidlertid sortere variabelen i stigende retning som standard.

> 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

Vær oppmerksom på at negativt fortegn brukes foran kolonnen Alder (-df $ Alder) for å sortere alderen i synkende rekkefølge. Alternativt kan det synkende argumentet brukes i denne posisjonen. Ordrefunksjonen brukes til å referere til kolonneindeksen i stedet for navnet på kolonnen. For eksempel i stedet for alder indeksreferansen til datarammen som vil være "1". Husk indeksverdiene begynner på "0".

I noen få tilfeller kan det hende at vi må sortere dataene med flere kriterier, dette kan oppnås i R ved hjelp av variabelnavn eller indeksnummer. I eksemplet nedenfor har jeg brukt mtcars-datasettet som er tilgjengelig i 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) ), )

I R er en alternativ måte å sortere dataene på ved å bruke dplyr-pakken. Denne pakken er veldig enkel å bruke og pålitelig med nøyaktige instruksjoner tilgjengelig.

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

Typer sortering i R

R er utstyrt med flere algoritmer for å utføre sortering på dataene. Nedenfor er de forskjellige typer sorteringsfunksjon. For å illustrere de forskjellige sorteringstypene brukes et utvalg av 10 tilfeldige tall fra en matrise.

1. Bubble Sort

I denne algoritmen blir to verdier sammenlignet ved siden av hverandre og elementer bytter plassering når kriteriene er oppfylt. Det kan være stigende eller i synkende rekkefølge. I boble sorteres par for elementer som er tilgjengelige i variabel, og elementer blir sammenlignet med hverandre, når et element er større enn et annet byttet de ut. Prosessen gjentas til det siste elementet.

> 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

Produksjon

2. Sett inn sortering

I innsettingssorteringsalgoritmen blir sorterte og usorterte elementer sammenlignet, og det usorterte elementet blir plassert på et passende sted etter hver iterasjon.

I denne algoritmen antas det første elementet å bli sortert og det andre elementet lagres separat som et nøkkelelement. Det sorterte elementet blir deretter sammenlignet med nøkkelen. Hvis det sorterte elementet er større enn nøkkelelementet, byttes stedene, og nøkkelelementet er det første elementet.

> 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

Produksjon

3. Utvalgssortering

Valgssorteringsfunksjonen er en mye brukt sorteringsalgoritme som brukes på R-språket. I denne typen sortering skyves det minste elementet fra den usorterte listen til begynnelsen av listen. I utvalgssorteringsalgoritmen blir det minste elementet fra rekken av den usorterte listen valgt og plassert i begynnelsen av den usorterte listen ved hver iterasjon. For eksempel, i en rekke med tall ordnet i en tilfeldig sekvens, velges startelement eller nummer som et minimum. I neste trinn sammenlignes det valgte minstetallet med neste element eller nummer. I tilfelle det sammenlignede elementet er mindre enn vårt valgte minimum, blir det andre elementet minimum. Denne prosessen itereres til det siste elementet.

> 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


Produksjon

4. Rask sortering

Quicksort-algoritmen fungerer som skill og regel. Det tilfeldige elementet er valgt som en pivot i en matrise, og deretter blir alle andre elementer unntatt pivot delt inn i to partisjoner. I neste trinn er alle elementene som er mindre enn og større enn pivoten delt i to forskjellige partisjoner. Til slutt blir elementene sortert ved hjelp av rekursjon.

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

Produksjon

5. Slå sammen sortering

Merge sort ligner imidlertid på quicksort, men her er matrisen delt i to like halvdeler. Merge sort algoritme har blitt delt inn i to deler en fusjon og en sorteringsfunksjon. Ved sammenslåing sorteres en liste ned i flere undelister til hver underliste består av et individuelt element. Sammenslåing av resultatene av undelister er en sortert liste.

> 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

Produksjon

6. HeapSort

Heap Sort-teknikken er veldig lik den med utvalgssortering der det minste elementet fra en usortert liste velges i hver iterasjon og steder i starten av listen. Heapsort-teknikken bruker imidlertid trekonsepter.

> 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

Produksjon

Konklusjon

I denne artikkelen har vi sett forskjellige måter data kan sorteres ved å bruke R. Vi har sett hvordan sortering og ordrekommandoer brukes til å sortere en dataramme, ytterligere begrensninger av sorteringsfunksjon over ordrefunksjon ble vist i artikkelen. En detaljert forklaring av forskjellige sorteringsalgoritmer som boble sortering, utvalg sortering og sammenslåing sortering har blitt grundig diskutert. Sortering er et av de viktigste trinnene i dataanalyse, og har forskjellige funksjoner for flere behov. Det er helt opp til dataingeniøren å velge den mest passende metoden for sortering basert på tilgjengelige data.

Anbefalte artikler

Dette har vært en guide til sortering i R. Her diskuterer vi hva som er sortering i R, funksjoner og typer sortering i R. Du kan også gå gjennom våre andre foreslåtte artikler for å lære mer -

1. Datavitenskapelig språk
2. Database i SQL
3. Datatyper i C
4. PostgreSQL-datatyper
5. Introduksjon til sortering i tableau
6. Sett inn Sorter i JavaScript
7. Komplett guide til sortering i C # med eksempler
8. Sorteringsfunksjon i Python med eksempler