Sissejuhatus sorteerimisse R

Sorteerimine on andmeanalüüsi üks olulisemaid aspekte. See on tehnika, mille kohaselt andmed paigutatakse või eraldatakse kindlas järjekorras. Andmed on sorteeritud, et saada vajalik teave andmekogumist. Näiteks korraldades andmete kasvavas järjekorras kuupäevavõtme alusel, siin on sortimiseks täpsustatud kriteeriumid. Seda toimingut saab hõlpsalt teha R-keele abil. R-keeles on mitu sortimisfunktsiooni, näiteks mullide sorteerimine ja valiku sorteerimine. Selles artiklis näeme erinevate sortimisfunktsioonide olulisust ja selgitame neid kõiki näidetega.

Sorteerimine toimub R-s

Andmeid saab R-s sortida mitmel viisil. Andmeanalüütik otsustab, milline on andmete struktuuril põhinev kõige sobivam meetod. R-keelel on andmete sortimiseks mitu funktsiooni ja viisi, näiteks sort (), order () ja dplyrI ().

Asjad, mida tuleks enne andmete sortimist meeles pidada.

  1. Järjekord, milles andmeid tuleb sortida kasvavalt või kahanevalt.
  2. Mitu veergu sortimiskriteeriumid.
  3. Puuduvate ja duplikaatväärtuste arvestamine sortimise ajal. Analüütiku otsustada, mida tuleb teha puuduvate ja dubleerivate väärtustega. Enne nullväärtuste eemaldamist või asendamist tuleks kaaluda andmete üldist mõju.

Sordi () funktsioon R-s

Sordi funktsiooni R-s kasutatakse vektori sortimiseks. Vaikimisi on väärtus korraldatud kasvavas järjekorras. Võtame näite kõigi klassiruumis õppivate õpilaste märkide veerust.

Süntaks vektori sortimiseks on

“sort (x, decreasing = FALSE)”

Siin x tähendab vektorit ja kui sortimine peab toimuma kahanevas järjekorras, tuleb vähendamine asendada väärtusega TRUE. Sorteerimise funktsiooni kasutatakse numbrilise või tähemärgivektori järjestamiseks soovitud järjekorras. Sorteerimise funktsiooni peamine piirang on see, et seda ei saa kasutada andmeraami sorteerimiseks. Selle piirangu ületamiseks kasutatakse funktsiooni Order ().

Põhiline sortimisnäide funktsiooni sort () abil

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

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

sorteeri (x)

Väljund

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

Andmeraame saab sorteerida funktsiooni order () abil. Muutujaid saab hõlpsalt sortida kas kasvavas või kahanevas järjekorras, kuid järjekorrafunktsioon sorteerib muutujad vaikimisi kasvavalt.

> 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

Pange tähele, et veeru Vanus (-df $ Age) ees kasutatakse negatiivset märki, et vanust sortida kahanevas järjekorras. Selles asendis võib kasutada ka laskuvat argumenti. Funktsiooni Tellimus kasutatakse veeru nime, mitte veeru nime viitamiseks. Näiteks vanuse asemel andmeraami indeksviide, mis oleks „1”. Indeksi väärtusi silmas pidades algab täht „0”.

Mõnel juhul võib olla vaja andmeid sortida mitme kriteeriumi abil, seda saab R-s saavutada muutujate nimede või indeksinumbrite abil. Allpool toodud näites olen kasutanud mtcarsi andmestikku, mis on saadaval R-stuudios.

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) ), )

R-is on alternatiivne viis andmete sortimiseks, kasutades paketti dplyr. Seda paketti on väga lihtne kasutada ja usaldusväärne, saadaval on täpsed juhised.

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

Sorteerimise tüübid R-s

R on varustatud mitmete algoritmidega andmete sortimiseks. Allpool on toodud erinevad sortimisfunktsioonide tüübid. Eri sorteerimistüüpide illustreerimiseks kasutatakse massiivi 10 juhusliku arvu valimit.

1. Mullide sortimine

Selles algoritmis võrreldakse kahte väärtust kõrvuti ja elemendid vahetavad oma positsiooni, kui kriteeriumid on täidetud. See võib olla kas kasvavas või kahanevas järjekorras. Mullide sortimisel moodustatakse muutujate jaoks saadaolevate elementide jaoks paarid ja elemente võrreldakse üksteisega, kui üks element on suurem kui teine, mida nad vahetasid. Protsessi korratakse kuni viimase elemendini.

> 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

Väljund

2. Sisestuse sortimine

Sisestamisalgoritmis võrreldakse sorteeritud ja sortimata elemente ning sortimata element asetatakse sobivasse kohta pärast iga iteratsiooni.

Selles algoritmis eeldatakse, et esimene element on sorteeritud ja teine ​​element salvestatakse võtmeelemendina eraldi. Seejärel võrreldakse sorteeritud elementi võtmega. Kui sorteeritud element on suurem kui võtmeelement, siis kohad vahetatakse ja võtmeelement on esimene 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

Väljund

3. Valiku sortimine

Sortimisfunktsioon on laialdaselt kasutatav sortimisalgoritm, mida kasutatakse R-keeles. Seda tüüpi sortimisel lükatakse sorteerimata loendist väikseim element loendi algusesse. Valiku sortimisalgoritmis valitakse sorteerimata nimekirja massiivi väikseim element ja asetatakse sorteerimata nimekirja algusesse igal iteratsioonil. Näiteks on juhuslikus järjestuses paigutatud numbrite reas minimaalselt valitud lähteelement või number. Järgmises etapis võrreldakse valitud minimaalset arvu järgmise elemendi või numbriga. Kui võrreldav element on väiksem kui meie valitud miinimum, saab teisest elemendist miinimum. Seda protsessi korratakse kuni viimase elemendini.

> 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

Väljund

4. Kiire sortimine

Quicksorti algoritm töötab sarnaselt jagamisele ja reeglitele. Juhuslik element valitakse massiivi pöördepunktina ja seejärel jagatakse kõik muud elemendid, välja arvatud pöördepunkt, kaheks osaks. Järgmises etapis jagatakse kõik elemendid, mis on pöördteljest väiksemad ja suuremad, kaheks erinevaks partitsiooniks. Lõpuks sorteeritakse elemendid rekursiooni abil.

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

Väljund

5. Ühenda sortimine

Ühendamise sort on väga sarnane kiirsortimisega, kuid siin on massiiv jagatud kaheks võrdseks pooleks. Ühendamise sortimise algoritm on jagatud kaheks osaks ühendamise ja sortimise funktsiooniks. Ühendatud sortimisel jaotatakse loend mitmeks alamloendiks, kuni iga alamloend koosneb eraldi elemendist. Nende alamloendite tulemuste liitmine on sorteeritud loend.

> 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

Väljund

6. HeapSort

Hunnikute sortimise tehnika on väga sarnane valiku sortimise tehnikaga, kus sorteerimata nimekirja väikseim element valitakse igas iteratsioonis ja paigutatakse nimekirja algusesse. Kuid hunniktehnikas kasutatakse puukontseptsioone.

> 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

Väljund

Järeldus

Selles artiklis oleme näinud erinevaid viise, kuidas andmeid saab sorteerida R. abil. Oleme näinud, kuidas sortimis- ja tellimiskäsku kasutatakse andmeraami sorteerimiseks. Artiklis näidati sortimisfunktsiooni täiendavad piirangud tellimisfunktsiooni suhtes. Erinevate sortimisalgoritmide, näiteks mullide sorteerimise, valiku sorteerimise ja liitmise sortimise üksikasjalikku selgitust on põhjalikult arutatud. Sorteerimine on andmeanalüüsi üks olulisemaid etappe ja sellel on mitmete vajaduste jaoks erinevad funktsioonid. Andmete insener otsustab olemasolevate andmete põhjal kõige sobivama sortimismeetodi.

Soovitatavad artiklid

See on olnud juhend R.-is sorteerimiseks. Siin käsitleme R-is sorteerimist, R.-is sortimise funktsioone ja tüüpe. Lisateabe saamiseks võite tutvuda ka meie teiste soovitatud artiklitega -

  1. Andmeteaduse keeled
  2. Andmebaas SQL-is
  3. Andmetüübid C-s
  4. PostgreSQL andmetüübid
  5. Sissejuhatus tabelisse sorteerimisse
  6. Sisestus Sorteeri JavaScriptis
  7. Täielik juhend C # -s sortimise kohta koos näidetega
  8. Näite abil sortimisfunktsioon Pythonis

Kategooria:

Suured andmed