Sorterer i R - Funktioner og typer af sortering i R med prøvekoder

• Introduktion til sortering i R

Introduktion til sortering i R

Sortering er et af de afgørende aspekter af dataanalyse. Det er en teknik, hvor data er arrangeret eller adskilt i en bestemt rækkefølge. Data sorteres for at udtrække de krævede oplysninger fra datasættet. For eksempel at arrangere dataene i stigende rækkefølge baseret på datatasten, her er kriterier blevet specificeret for at sortere. Denne handling kan let udføres ved hjælp af R-sproget. På R-sprog er der flere sorteringsfunktioner såsom boble sortering og valg af sortering. I denne artikel vil vi se vigtigheden af ​​forskellige sorteringsfunktioner og forklare hver af dem med eksempler.

Sortering udført i R

Der er flere måder, hvorpå data kan sorteres i R. Det er op til dataanalytikeren at overveje den bedst egnede metode baseret på datastrukturen. R-sprog har flere funktioner og måder til at sortere dataene som pakke sortering (), rækkefølge () og dplyrI ().

Ting at huske på, inden du sorterer dataene.

1. Ordre, i hvilken data skal sorteres stigende eller faldende.
2. Kriterier for sortering af flere kolonner.
3. Regnskab mangler og duplikerede værdier under sortering. Det er op til analytikeren at beslutte, hvad der skal gøres med de manglende og duplikatværdier. Før du fjerner eller udskifter nulværdier, skal den samlede indvirkning på dataene overvejes.

Sorter () -funktion i R

Sorteringsfunktion i R bruges til at sortere en vektor. Som standard er værdien organiseret i stigende rækkefølge. Lad os tage et eksempel på mærkesøjlen for alle studerende i et klasseværelse.

Syntaks for at sortere vektoren er

“sort (x, decreasing = FALSE)”

Her henviser x til vektoren, og faldende skal erstattes til SAND, når sorteringen skal udføres i faldende rækkefølge. Sorteringsfunktionen bruges til at arrangere numerisk eller tegnvektor i den ønskede rækkefølge. Den største begrænsning af sorteringsfunktionen er, at den ikke kan bruges til at sortere en dataramme. For at overvinde denne begrænsning anvendes funktionen Order ().

Et grundlæggende sorteringseksempel ved hjælp af funktionen sortering ()

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

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

sortering (x)

Produktion

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

Sortering af datarammer kan udføres ved hjælp af funktionen ordre (). Variabler kan let sorteres i enten stigende eller faldende rækkefølge. Ordrefunktionen sorterer imidlertid variablen i stigende tilstand 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

Bemærk, at der anvendes negativt tegn foran kolonnen Alder (-df $ Alder) for at sortere alderen i faldende rækkefølge. Alternativt kan det faldende argument bruges i denne position. Ordrefunktionen bruges til at henvise til kolonneindekset snarere end navnet på kolonnen. For eksempel i stedet for alder indeksreference for datarammen, der ville være “1”. Husk indeksværdier begynder et "0".

I nogle få tilfælde er vi muligvis nødt til at sortere dataene med flere kriterier, dette kan opnås i R ved hjælp af variabelnavne eller indeksnumre. I nedenstående eksempel har jeg brugt det mtcars datasæt, der er tilgængeligt 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åde at sortere dataene ved hjælp af dplyr-pakken. Denne pakke er meget nem at bruge og pålidelig med nøjagtige instruktioner til rådighed.

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

Typer af sortering i R

R er udstyret med flere algoritmer til udførelse af sortering på dataene. Nedenfor er de forskellige typer sorteringsfunktion. For at illustrere de forskellige typer sortering bruges en prøve af 10 tilfældige tal fra en matrix.

1. Bubble Sort

I denne algoritme sammenlignes to værdier side om side, og elementer bytter deres placering, når kriterierne er opfyldt. Det kan enten være stigende eller i faldende rækkefølge. I boble sorteres par for elementer, der er tilgængelige i variabel, og elementer sammenlignes med hinanden, når et element er større end et andet, de byttet. Processen gentages indtil det sidste element.

> 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. Indsættelsessortering

I indsættelsessorteringsalgoritme sammenlignes sorterede og usorterede elementer, og det usorterede element placeres et passende sted efter hver iteration.

I denne algoritme antages, at det første element sorteres, og det andet element gemmes separat som et nøgleelement. Det sorterede element sammenlignes derefter med nøglen. Hvis det sorterede element er større end nøgleelementet, byttes pladserne, og nøgleelementet er det første element.

> 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. Valgssortering

Valgsorteringsfunktionen er en meget brugt sorteringsalgoritme, der bruges på R-sproget. I denne type sortering skubbes det mindste element fra den usorterede liste til starten af ​​listen. I valgsorteringsalgoritmen vælges det mindste element fra matrixen af ​​den usorterede liste og placeres i starten af ​​den usorterede liste ved hver iteration. For eksempel vælges i en række numre arrangeret i en tilfældig sekvens startelement eller nummer som et minimum. I det næste trin sammenlignes det valgte minimumsnummer med det næste element eller nummer. I tilfælde af at det sammenlignede element er mindre end vores valgte minimum, bliver det andet element minimum. Denne proces itereres indtil det sidste element.

> 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. Hurtig sortering

Quicksort-algoritmen fungerer som split og regel. Det tilfældige element vælges som en pivot i en matrix, og derefter er alle andre elementer undtagen pivot opdelt i to partitioner. I det næste trin er alle elementer, der er mindre end og større end drejepoten, opdelt i to forskellige partitioner. Endelig sorteres elementerne ved hjælp af 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. Flet sortering

Flettesorter er dog meget lig quicksort, her er arrayet delt i to lige store halvdele. Flet sorteringsalgoritme er blevet opdelt i to dele en fletning og en sorteringsfunktion. Ved sammenfletning sorteres en liste ned i flere undelister, indtil hver underliste består af et individuelt element. Det er en sorteret liste, at sammenlægge disse undelisterresultater.

> 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 ligner meget den, der vælges, hvor det mindste element fra en usorteret liste vælges i hver iteration og placeres i starten af ​​listen. Heapsort-teknikken bruger imidlertid trækoncepter.

> 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

Konklusion

I denne artikel har vi set forskellige måder, hvor data kan sorteres ved hjælp af R. Vi har set, hvordan sortering og rækkefølge-kommando bruges til at sortere en dataramme, yderligere begrænsninger af sorteringsfunktion frem for ordrefunktion blev vist i artiklen. En detaljeret forklaring af forskellige sorteringsalgoritmer, såsom bobelsortering, udvælgelsessortering og sammenfletningssortering, er blevet grundigt diskuteret. Sortering er et af de vigtigste trin i dataanalyse og har forskellige funktioner til flere behov. Det er helt op til dataingeniøren at vælge den mest passende metode til sortering baseret på de tilgængelige data.

Anbefalede artikler

Dette har været en guide til sortering i R. Her diskuterer vi, hvad der sorteres i R, funktioner og typer af sortering i R. Du kan også gennemgå vores andre foreslåede artikler for at lære mere -

1. Data Science Sprog
2. Database i SQL
3. Datatyper i C
4. PostgreSQL-datatyper
5. Introduktion til sortering i Tableau
6. Indsættelse Sorter i JavaScript
7. Komplet guide til sortering i C # med eksempler
8. Sorteringsfunktion i Python med eksempler