Lajittelu R - R-lajittelun funktiot ja tyypit näytekoodeilla

• Johdatus lajitteluun R: ssä

Johdatus lajitteluun R: ssä

Lajittelu on yksi tietoanalyysin tärkeimmistä näkökohdista. Se on tekniikka, jossa tiedot järjestetään tai erotellaan tietyssä järjestyksessä. Tiedot lajitellaan tarvittavien tietojen poistamiseksi tietojoukosta. Esimerkiksi järjestämällä tiedot nousevassa järjestyksessä päivämääräavaimen perusteella, tässä kriteerit on määritelty lajittelua varten. Tämä toimenpide voidaan suorittaa helposti käyttämällä R-kieltä. R-kielellä on useita lajittelutoimintoja, kuten kuplalajittelu ja valintalaji. Tässä artikkelissa nähdään erilaisten lajittelutoimintojen merkitys ja selitetään niitä jokaisella esimerkkejä.

Lajittelu suoritetaan R: ssä

Tietoja voidaan lajitella R-muodossa monella tapaa. Tietoanalyytikon on arvioitava sopivin menetelmä, joka perustuu datan rakenteeseen. R-kielellä on useita toimintoja ja tapoja lajitella tietoja, kuten lajittelu (), järjestys () ja dplyrI () -paketti.

Asiat, jotka on pidettävä mielessä ennen tietojen lajittelua.

1. Järjestys, jossa tiedot on lajiteltava nousevaan tai laskevaan.
2. Useita sarakkeita lajitteluperusteet.
3. Puuttuvien ja päällekkäisten arvojen kirjanpito lajittelun aikana. Analyytikon on päätettävä, mitä puuttuville ja kaksoisarvoille on tehtävä. Ennen nolla-arvojen poistamista tai korvaamista on otettava huomioon kokonaisvaikutus tietoihin.

Lajittele () -toiminto R: ssä

R-lajittelutoimintoa käytetään vektorin lajitteluun. Oletusarvon mukaan arvo on järjestetty nousevassa järjestyksessä. Otetaan esimerkki kaikkien luokkahuoneessa olevien oppilaiden merkkipylväästä.

Syntaksi vektorin lajittelua varten on

“sort (x, decreasing = FALSE)”

Tässä x viittaa vektoriin ja pienenevä on korvattava TODELLISEKSI, kun lajittelu on tehtävä alenevassa järjestyksessä. Lajittelutoimintoa käytetään numeerisen tai merkkivektorin järjestämiseen halutussa järjestyksessä. Lajittelutoiminnon suurin rajoitus on, että sitä ei voida käyttää tietokehyksen lajitteluun. Tämän rajoituksen voittamiseksi käytetään Order () -toimintoa.

Peruslajitteluesimerkki lajittelu () -toiminnolla

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

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

sort (X)

ulostulo

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

Tietokehysten lajittelu voidaan suorittaa order () -toiminnon avulla. Muuttujat voidaan lajitella helposti nousevaan tai laskevaan järjestykseen. Järjestystoiminto lajittelee muuttujan oletuksena nousevaan järjestykseen.

> 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

Huomaa, että negatiivista merkkiä käytetään Ikä-sarakkeen (-df $ Age) edessä iän järjestämiseksi alenevassa järjestyksessä. Laskevaa argumenttia voidaan vaihtoehtoisesti käyttää tässä asennossa. Tilaa-toimintoa käytetään viitaamaan sarakehakemistoon sarakkeen nimen sijasta. Esimerkiksi iän sijaan tietokehyksen hakemistoviittaus, joka olisi ”1”. Hakemistoarvojen mielessä alkaa “0”.

Joissain tapauksissa saatamme joutua lajittelemaan tiedot useilla kriteereillä. Tämä voidaan saavuttaa R: ssä käyttämällä muuttujien nimiä tai hakemistonumeroita. Alla olevassa esimerkissä olen käyttänyt mtcars-tietojoukkoa, joka on saatavana R-studiosta.

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: ssä vaihtoehtoinen tapa lajitella tietoja on käyttämällä dplyr-pakettia. Tämä paketti on erittäin helppo käyttää ja luotettava, ja tarkat ohjeet ovat saatavilla.

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

Lajittelulajit R: ssä

R on varustettu useilla algoritmeilla datan lajittelun suorittamiseksi. Alla on erityyppiset lajittelutoiminnot. Eri tyyppisten lajittelun havainnollistamiseksi käytetään taulukkoa koskevaa 10 satunnaisluvun näytettä.

1. Kuplalajittelu

Tässä algoritmissa verrataan kahta arvoa vierekkäin ja elementit vaihtavat sijaintinsa, kun kriteerit täyttyvät. Se voi olla joko nousevassa tai laskevassa järjestyksessä. Kuplalajittelussa muodostuu pareja muuttujille saatavissa oleville elementeille ja elementtejä verrataan toisiinsa, kun yksi elementti on suurempi kuin toinen, ne vaihdetaan. Prosessi toistetaan viimeiseen elementtiin asti.

> 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

ulostulo

2. Lisäyslajittelu

Lisäyslajittelualgoritmissa verrataan lajiteltuja ja lajittelemattomia elementtejä, ja lajittelematon elementti asetetaan sopivaan paikkaan jokaisen iteraation jälkeen.

Tässä algoritmissa oletetaan, että ensimmäinen elementti on lajiteltu ja toinen elementti tallennetaan erikseen avainelementiksi. Lajiteltua elementtiä verrataan sitten avaimeen. Jos lajiteltu elementti on suurempi kuin avainelementti, paikat vaihdetaan ja avainelementti on ensimmäinen elementti.

> 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

ulostulo

3. Valintalajittelu

Valinnan lajittelutoiminto on laajasti käytetty R-kielessä käytetty lajittelualgoritmi. Tämän tyyppisessä lajittelussa pienin elementti lajittelemattomasta luettelosta työnnetään luettelon alkuun. Valinnanlajittelualgoritmissa valitaan lajittelemattoman luettelon ryhmän pienin elementti ja sijoitetaan lajittelemattoman luettelon alkuun jokaisen toiston yhteydessä. Esimerkiksi satunnaisessa järjestyksessä järjestetyssä numerorivissä lähtöelementti tai numero valitaan minimiksi. Seuraavassa vaiheessa valittua vähimmäismäärää verrataan seuraavaan elementtiin tai numeroon. Jos vertailtu elementti on pienempi kuin valittu minimi, toisesta elementistä tulee minimi. Tätä prosessia toistetaan viimeiseen elementtiin saakka.

> 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


ulostulo

4. Pikalajittelu

Quicksort-algoritmi toimii kuten jakaa ja hallita. Satunnainen elementti valitaan nivelaineena taulukossa ja sitten kaikki muut elementit paitsi pivot jaetaan kahteen osioon. Seuraavassa vaiheessa kaikki elementit, jotka ovat pienempiä ja suurempia kuin nivel, jaetaan kahteen erilliseen osioon. Lopuksi elementit lajitellaan rekursion avulla.

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

ulostulo

5. Yhdistä lajittelu

Yhdistämislajittelu on hyvin samanlainen kuin pikalukitus, mutta tässä taulukko on jaettu kahteen yhtä suureen puolikkaaseen. Yhdistämisalgoritmi on jaettu kahteen osaan yhdistämis- ja lajittelutoiminto. Yhdistetyssä lajittelussa luettelo jaotellaan useisiin alaluetteloihin, kunnes jokainen alaluettelo koostuu yksittäisestä elementistä. Näiden alaluetteloiden tulosten yhdistäminen on lajiteltu luettelo.

> 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

ulostulo

6. HeapSort

Heap Sort -tekniikka on hyvin samankaltainen kuin selection lajittelu, jossa lajittelemattoman luettelon pienin elementti valitaan jokaisessa iteraatiossa ja paikat luettelon alussa. Laajan kannan tekniikka käyttää kuitenkin puukäsitteitä.

> 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

ulostulo

johtopäätös

Tässä artikkelissa olemme nähneet erilaisia ​​tapoja lajitella tietoja R: n avulla. Olemme nähneet kuinka lajittelu- ja tilauskomentoa käytetään tietokehyksen lajitteluun. Artikkelissa esitettiin lajittelufunktion lisärajoitukset tilaustoiminnon suhteen. Yksityiskohtainen selitys erilaisista lajittelualgoritmeista, kuten kuplalajittelu, valintalaji ja yhdistelmälajittelu, on käsitelty perusteellisesti. Lajittelu on yksi tärkeimmistä tietojen analysoinnin vaiheista, ja sillä on erilaisia ​​toimintoja useisiin tarpeisiin. Tietotekniikan tehtävänä on valita sopivin lajittelutapa käytettävissä olevien tietojen perusteella.

Suositellut artikkelit

Tämä on opas lajitteluun R: ssä. Tässä keskustellaan siitä, mikä on lajittelu R: ssä, ominaisuudet ja tyypit R: ssä. Voit myös käydä läpi muita ehdottamiasi artikkeleitamme saadaksesi lisätietoja -

1. Data Science Kielet
2. Tietokanta SQL: ssä
3. Tietotyypit C: ssä
4. PostgreSQL-tietotyypit
5. Johdanto lajitteluun Tableaussa
6. Lisäys Lajittele JavaScriptiin
7. Täydellinen opas lajitteluun C # -merkinnällä esimerkkeinä
8. Järjestämistoiminto Pythonissa esimerkkien avulla