Sorterar i R - Funktioner och typer av sortering i R med sampelkoder

• Introduktion till sortering i R

Introduktion till sortering i R

Sortering är en av de avgörande aspekterna av dataanalys. Det är en teknik där data ordnas eller segregeras i en specifik ordning. Data sorteras för att extrahera den information som krävs från datasatsen. Till exempel, ordna uppgifterna i stigande ordning baserat på datumnyckeln, här har kriterier angetts för att sortera. Denna operation kan enkelt utföras med R-språket. På R-språk finns det flera sorteringsfunktioner som bubbelsortering och urvalssortering. I den här artikeln kommer vi att se vikten av olika sorteringsfunktioner och förklara var och en av dem med exempel.

Sortering utförs i R

Det finns flera sätt på vilka data kan sorteras i R. Det är upp till dataanalytiker att ta hänsyn till den mest lämpliga metoden baserat på datorns struktur. R-språket har flera funktioner och sätt att sortera data som sortering (), ordning () och dplyrI () -paket.

Saker att tänka på innan du sorterar data.

1. Ordning i vilken data måste sorteras stigande eller fallande.
2. Sorteringskriterier för flera kolumner.
3. Redovisning saknas och duplicerade värden under sortering. Det är upp till analytikern att bestämma vad som måste göras med de saknade och duplicerade värdena. Innan du tar bort eller ersätter nollvärden, bör den totala påverkan på data övervägas.

Sortera () -funktionen i R

Sorteringsfunktion i R används för att sortera en vektor. Som standard är värdet organiserat i stigande ordning. Låt oss ta ett exempel på märkespalten för alla elever i ett klassrum.

Syntaxen för att sortera vektorn är

“sort (x, decreasing = FALSE)”

Här hänvisar x till vektorn och minskning måste ersättas till SANT när sorteringen måste göras i fallande ordning. Sorteringsfunktionen används för att ordna numerisk eller teckenvektor i önskad ordning. Den största begränsningen för sorteringsfunktionen är att den inte kan användas för att sortera en dataram. För att övervinna denna begränsning används funktionen Order ().

Ett grundläggande sorteringsexempel med funktionen sortering ()

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

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

sort (x)

Produktion

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

Sortering av dataramar kan utföras med hjälp av orderfunktionen (). Variabler kan enkelt sorteras i antingen stigande eller fallande ordning, men ordningsfunktionen sorterar variabeln i stigande 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

Observera att negativt tecken används framför kolumnen Ålder (-df $ Ålder) för att sortera åldern i fallande ordning. Alternativt kan det fallande argumentet användas i denna position. Orderfunktionen används för att referera till kolumnindex snarare än kolumnens namn. Till exempel i stället för ålder indexreferensen för dataramen som skulle vara ”1”. Tänk på att indexvärden börjar med ”0”.

I några få fall kan vi behöva sortera data med flera kriterier, detta kan uppnås i R med hjälp av variabla namn eller indexnummer. I exemplet nedan har jag använt mtcars-datasättet som är tillgängligt 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 är ett alternativt sätt att sortera data genom att använda dplyr-paketet. Detta paket är mycket enkelt att använda och pålitligt med exakta instruktioner tillgängliga.

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

Typer av sortering i R

R är utrustad med flera algoritmer för att utföra sortering på data. Nedan visas de olika typerna av sorteringsfunktion. För att illustrera de olika typerna av sortering används ett prov med 10 slumpmässiga nummer från en matris.

1. Bubble Sort

I denna algoritm jämförs två värden sida vid sida och element byter sin position när kriterierna är uppfyllda. Det kan antingen vara stigande eller i fallande ordning. I bubbelsorter bildas par för element som är tillgängliga i variabel och element jämförs mot varandra, när ett element är större än ett annat bytte de. Processen upprepas tills det sista 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

Produktion

2. Insertion Sort

I införingssorteringsalgoritmen jämförs sorterade och osorterade element och det osorterade elementet placeras på en lämplig plats efter varje iteration.

I denna algoritm antas det första elementet att sorteras och det andra elementet lagras separat som ett nyckelelement. Det sorterade elementet jämförs sedan med nyckeln. Om det sorterade elementet är större än nyckelelementet byts platserna och nyckelelementet är det första 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

Produktion

3. Val av sortering

Urvalssorteringsfunktionen är en mycket använt sorteringsalgoritm som används på R-språket. I den här typen av sortering skjuts det minsta elementet från den osorterade listan till början av listan. I urvalsorteringsalgoritmen väljs det minsta elementet från matrisen för den osorterade listan och placeras i början av den osorterade listan vid varje iteration. Till exempel, i en rad med nummer ordnade i en slumpmässig sekvens väljs startelement eller nummer som ett minimum. I nästa steg jämförs det valda minsta antalet med nästa element eller nummer. Om det jämförda elementet är mindre än vårt valda minimum blir det andra elementet det minsta. Denna process itereras till det sista 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


Produktion

4. Snabbsortering

Quicksort-algoritmen fungerar som splittring och regel. Det slumpmässiga elementet väljs som en pivot i en matris och sedan delas alla andra element utom pivot i två partitioner. I nästa steg delas alla element som är mindre än och större än pivoten i två olika partitioner. Slutligen sorteras elementen med rekursion.

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

Produktion

5. Slå samman

Merge sort är dock mycket lik quicksort men här är matrisen uppdelad i två lika halvor. Merge sort algoritm har delats upp i två delar en sammanslagning och en sorteringsfunktion. I sammanslagningssortering är en lista uppdelad i flera underlistor tills varje dellista består av ett enskilt element. Att slå samman de här listorna är en sorterad lista.

> 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

Produktion

6. HeapSort

Heap Sort-teknik är mycket lik den för urvalsorter där det minsta elementet från en osorterad lista väljs i varje iteration och platser i början av listan. Heapsort-tekniken använder emellertid trädkoncept.

> 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

Produktion

Slutsats

I den här artikeln har vi sett olika sätt data kan sorteras med R. Vi har sett hur sortering och ordningskommando används för att sortera en dataram, ytterligare begränsningar av sorteringsfunktion över ordningsfunktion visades i artikeln. En detaljerad förklaring av olika sorteringsalgoritmer som bubbelsortering, urvalssortering och sammanslagningssortering har diskuterats noggrant. Sortering är ett av de viktigaste stegen i dataanalys och har olika funktioner för flera behov. Det är helt upp till datatekniker att välja den lämpligaste metoden för sortering baserat på tillgängliga data.

Rekommenderade artiklar

Detta har varit en guide till sortering i R. Här diskuterar vi vad som sorterar i R, funktioner och sorteringstyper i R. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -

1. Datavetenskapsspråk
2. Databas i SQL
3. Datatyper i C
4. PostgreSQL-datatyper
5. Introduktion till sortering i tablå
6. Insättning Sortera i JavaScript
7. Komplett guide till sortering i C # med exempel
8. Sorteringsfunktion i Python med exempel