Sorteren in R - Functies en soorten sorteren in R met voorbeeldcodes

• Inleiding tot sorteren in R

Inleiding tot sorteren in R

Sorteren is een van de cruciale aspecten van gegevensanalyse. Het is een techniek waarbij gegevens in een specifieke volgorde worden gerangschikt of gescheiden. Gegevens worden gesorteerd om de vereiste informatie uit de gegevensset te extraheren. Als u de gegevens bijvoorbeeld in oplopende volgorde wilt rangschikken op basis van de datumcode, zijn hier criteria opgegeven om te sorteren. Deze bewerking kan eenvoudig worden uitgevoerd met de R-taal. In de R-taal zijn er meerdere sorteerfuncties zoals bubbelsortering en selectiesortering. In dit artikel zullen we het belang van verschillende sorteerfuncties zien en elk van hen met voorbeelden uitleggen.

Sorteren Uitgevoerd in R

Er zijn meerdere manieren waarop gegevens kunnen worden gesorteerd in R. Het is aan de gegevensanalist om de meest geschikte methode te overwegen op basis van de structuur van de gegevens. R-taal heeft meerdere functies en manieren om de gegevens te sorteren, zoals sort (), order () en dplyrI () -pakket.

Dingen om in gedachten te houden voordat u de gegevens sorteert.

1. Volgorde waarin gegevens moeten worden gesorteerd oplopend of aflopend.
2. Sorteercriteria voor meerdere kolommen.
3. Boekhoudkundige ontbrekende en dubbele waarden tijdens het sorteren. Het is aan de analist om te beslissen wat er moet worden gedaan met de ontbrekende en dubbele waarden. Voordat u null-waarden verwijdert of vervangt, moet u rekening houden met de algehele impact op de gegevens.

Sorteerfunctie () in R

Sorteerfunctie in R wordt gebruikt om een ​​vector te sorteren. Standaard wordt de waarde georganiseerd in oplopende volgorde. Laten we een voorbeeld nemen van de kolom van het merk van alle studenten in een klaslokaal.

De syntaxis om de vector te sorteren is

“sort (x, decreasing = FALSE)”

Hier verwijst x naar de vector en moet afnemen worden vervangen door WAAR wanneer het sorteren in aflopende volgorde moet worden uitgevoerd. De sorteerfunctie wordt gebruikt om de numerieke of tekenvector in de gewenste volgorde te rangschikken. De belangrijkste beperking van de sorteerfunctie is dat deze niet kan worden gebruikt om een ​​gegevensframe te sorteren. Om deze beperking op te lossen, wordt de functie Order () gebruikt.

Een eenvoudig sorteervoorbeeld met de functie sort ()

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

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

sort (x)

uitgang

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

Het sorteren van gegevensframes kan worden bereikt met behulp van de functie order (). Variabelen kunnen eenvoudig worden gesorteerd in oplopende of aflopende volgorde, maar de sorteerfunctie sorteert de variabele standaard in oplopend.

> 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

Let op: het negatieve teken wordt gebruikt voor de kolom Leeftijd (-df $ Leeftijd) om de leeftijd in aflopende volgorde te sorteren. Als alternatief kan het aflopende argument in deze positie worden gebruikt. De functie Order wordt gebruikt om naar de kolomindex te verwijzen in plaats van de naam van de kolom. Bijvoorbeeld in plaats van leeftijd de indexreferentie van het gegevensframe die "1" zou zijn. Indachtig indexwaarden beginnen een "0".

In enkele gevallen moeten we de gegevens mogelijk met meerdere criteria sorteren, dit kan in R worden bereikt met behulp van variabelenamen of indexnummers. In het onderstaande voorbeeld heb ik de mtcars-gegevensset gebruikt die beschikbaar is 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 is een alternatieve manier om de gegevens te sorteren met het pakket dplyr. Dit pakket is zeer gemakkelijk te gebruiken en betrouwbaar met nauwkeurige instructies beschikbaar.

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

Soorten sortering in R

R is uitgerust met meerdere algoritmen om de gegevens te sorteren. Hieronder staan ​​de verschillende soorten sorteerfuncties. Om de verschillende soorten sortering te illustreren, wordt een steekproef van 10 willekeurige getallen uit een array gebruikt.

1. Bellen sorteren

In dit algoritme worden twee waarden naast elkaar vergeleken en wisselen elementen hun positie wanneer aan de criteria wordt voldaan. Het kan oplopend of aflopend zijn. In bubbelsoort worden paren gevormd voor elementen die beschikbaar zijn in variabele en elementen worden met elkaar vergeleken, wanneer een element groter is dan een ander, verwisselden ze. Het proces wordt herhaald tot het laatste 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

uitgang

2. Invoegsortering

In het invoegsorteeralgoritme worden gesorteerde en ongesorteerde elementen vergeleken en wordt het ongesorteerde element na elke iteratie op een geschikte plaats geplaatst.

In dit algoritme wordt aangenomen dat het eerste element wordt gesorteerd en het tweede element afzonderlijk wordt opgeslagen als een sleutelelement. Het gesorteerde element wordt vervolgens vergeleken met de sleutel. Als het gesorteerde element groter is dan het sleutelelement, worden de plaatsen verwisseld en is het sleutelelement het eerste 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

uitgang

3. Selectie sorteren

De selectie-sorteerfunctie is een veel gebruikt sorteeralgoritme dat in de R-taal wordt gebruikt. Bij dit soort sorteren wordt het kleinste element uit de ongesorteerde lijst naar het begin van de lijst gepusht. In het selectie-sorteeralgoritme wordt het kleinste element uit de reeks van de ongesorteerde lijst geselecteerd en bij elke iteratie aan het begin van de ongesorteerde lijst geplaatst. In een rij met getallen die in een willekeurige reeks zijn gerangschikt, wordt het startelement of nummer bijvoorbeeld minimaal geselecteerd. In de volgende stap wordt het geselecteerde minimumaantal vergeleken met het volgende element of nummer. In het geval dat het vergeleken element kleiner is dan ons geselecteerde minimum, wordt het tweede element het minimum. Dit proces wordt herhaald tot het laatste 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


uitgang

4. Snel sorteren

Quicksort-algoritme werkt als verdeel en heers. Het willekeurige element wordt geselecteerd als een pivot in een array en vervolgens worden alle andere elementen behalve pivot verdeeld in twee partities. In de volgende stap worden alle elementen die kleiner dan en groter zijn dan de pivot verdeeld in twee verschillende partities. Ten slotte worden de elementen gesorteerd met behulp van recursie.

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

uitgang

5. Sorteren samenvoegen

Het samenvoegen sorteert echter erg op quicksort, hier is de array verdeeld in twee gelijke helften. Sorteeralgoritme is onderverdeeld in twee delen: een samenvoegfunctie en een sorteerfunctie. Bij het samenvoegen wordt een lijst opgesplitst in meerdere sublijsten totdat elke sublijst uit een afzonderlijk element bestaat. Het samenvoegen van die sublijstresultaten is een gesorteerde lijst.

> 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

uitgang

6. HeapSort

Heap Sort-techniek lijkt sterk op die van selectiesortering waarbij het kleinste element uit een ongesorteerde lijst in elke iteratie wordt geselecteerd en aan het begin van de lijst wordt geplaatst. De heapsort-techniek gebruikt echter boomconcepten.

> 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

uitgang

Conclusie

In dit artikel hebben we verschillende manieren gezien waarop gegevens kunnen worden gesorteerd met behulp van R. We hebben gezien hoe sorteer- en bestelopdracht worden gebruikt om een ​​dataframe te sorteren, verdere beperkingen van sorteerfunctie boven bestelfunctie werden in het artikel getoond. Een gedetailleerde uitleg van verschillende sorteeralgoritmen zoals bubbelsortering, selectiesortering en samenvoegsortering is grondig besproken. Sorteren is een van de belangrijkste stappen van gegevensanalyse en heeft verschillende functies voor meerdere behoeften. Het is volledig aan de data engineer om de meest geschikte methode voor het sorteren op basis van de beschikbare gegevens te kiezen.

Aanbevolen artikelen

Dit is een gids voor Sorteren in R. Hier bespreken we wat sorteren in R, functies en soorten sorteren in R. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -

1. Data Science-talen
2. Database in SQL
3. Gegevenstypen in C
4. PostgreSQL-gegevenstypen
5. Inleiding tot sorteren in Tableau
6. Invoegsortering in JavaScript
7. Volledige gids voor sorteren in C # met voorbeelden
8. Sorteerfunctie in Python met voorbeelden