Rendezés R - -ben A szétválogatás funkciói és típusai R mintákkal

• Bevezetés a válogatásba R

Bevezetés a válogatásba R

Az osztályozás az adatelemzés egyik kritikus szempontja. Ez egy technika, amelyben az adatokat meghatározott sorrendben rendezik el vagy szétválasztják. Az adatokat rendezzük annak érdekében, hogy a szükséges információt kinyerjük az adatkészletből. Például, ha az adatokat növekvő sorrendben rendezi a dátum kulcs alapján, itt a kritériumokat meghatározták a rendezés érdekében. Ez a művelet könnyen elvégezhető az R nyelv használatával. Az R nyelvben többféle rendezési funkció létezik, például a buborék rendezése és a szelekció. Ebben a cikkben meglátjuk a különféle rendezési funkciók fontosságát, és mindegyiket példákkal magyarázzuk.

A válogatást R-ben végezzük

Az adatok R-ben történő rendezésének többféle módja van. Az adatelemző feladata, hogy mérlegelje az adatok felépítése alapján a legmegfelelőbb módszert. Az R nyelvnek több funkciója és módja van az adatok rendezésére, például a sort (), order () és dplyrI () pack.

Az adatok rendezése előtt szem előtt tartandó dolgok.

1. Az adatok sorrendje növekvő vagy csökkenő sorrendben.
2. Több oszlop válogatási kritériumai.
3. Hiányzó és másodpéldányos értékek elszámolása a rendezés során. Az elemzőnek kell eldöntenie, hogy mit kell tenni a hiányzó és az ismétlődő értékekkel. A nulla értékek eltávolítása vagy cseréje előtt figyelembe kell venni az adatokra gyakorolt ​​általános hatást.

Rendezés () függvény R-ben

Az R rendezési funkciója a vektor rendezésére szolgál. Alapértelmezés szerint az érték növekvő sorrendben van rendezve. Vegyünk egy példát az osztálytermi összes tanuló jelölés oszlopára.

A vektor rendezésének szintaxisa

“sort (x, decreasing = FALSE)”

Itt x a vektort jelöli, és a csökkenést TRUE értékre kell váltani, ha a válogatást csökkenő sorrendben kell elvégezni. A rendezési funkciót a numerikus vagy karaktervektor kívánt sorrendbe rendezéséhez használjuk. A rendezési funkció fő korlátozása az, hogy nem használható adatkeret rendezésére. E korlátozás leküzdésére a Order () függvényt használjuk.

Alapvető rendezési példa a sort () függvény használatával

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

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

sort (x)

Kimenet

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

Az adatkeretek rendezése a order () függvény segítségével valósítható meg. A változók könnyen növekvő vagy csökkenő sorrendbe rendezhetők, azonban a rendelési funkció alapértelmezés szerint növekvő sorrendben rendezi a változókat.

> 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

Felhívjuk figyelmét, hogy a negatív jelet az Életkor oszlop előtt (-df $ Életkor) használják az Életkor csökkenő sorrendbe rendezése érdekében. Alternatív megoldásként a csökkenő érv is használható ebben a helyzetben. A Rendelés funkció az oszlop nevére, és nem az oszlop indexére utal. Például az életkor helyett az 1-es adatkeret index-referenciája. Az indexértékek szem előtt tartásával „0” kezdődik.

Néhány esetben előfordulhat, hogy az adatokat több kritérium alapján kell osztályoznunk, ez R-ben érhető el változó nevek vagy indexszámok segítségével. Az alábbi példában az mtcars adatkészletet használtam, amely az R stúdióban elérhető.

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-ben az adatok rendezésének alternatív módja a dplyr csomag használata. Ez a csomag nagyon könnyen használható és megbízható, pontos utasításokkal elérhető.

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

Rendezés típusai R-ben

Az R több algoritmussal van felszerelve az adatok rendezéséhez. Az alábbiakban bemutatjuk a különféle típusú rendezési funkciókat. A különféle rendezési típusok szemléltetésére egy tömbből 10 véletlenszerű számot használunk.

1. Bubble Sort

Ebben az algoritmusban két értéket hasonlítanak össze egymással, és az elemek cserélik egymás helyét, amikor a kritériumok teljesülnek. Lehet növekvő vagy csökkenő sorrendben. Buborék rendezésben párok alakulnak ki a változóban elérhető elemek számára, és az elemeket összehasonlítják egymással, ha az egyik elem nagyobb, mint a másik, akkor cserélték őket. A folyamatot megismételjük az utolsó elemig.

> 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

Kimenet

2. Beszúrás rendezése

A beszúrási rendezési algoritmusban összehasonlítják a rendezett és a válogatás nélküli elemeket, és a válogatás nélküli elemet minden egyes iteráció után megfelelő helyre helyezik.

Ebben az algoritmusban feltételezzük, hogy az első elem rendezve van, és a második elemet külön tárolják kulcs elemként. Ezután a rendezett elemet összehasonlítják a kulccsal. Ha a rendezett elem nagyobb, mint a kulcs elem, akkor a helyeket felcserélik, és a kulcs elem az első elem.

> 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

Kimenet

3. Kiválasztás Rendezés

A szelekciós rendezési funkció egy széles körben használt válogatási algoritmus, amelyet az R nyelven használnak. Az ilyen típusú válogatás során a válogatott listából a legkisebb elem a lista elejére kerül. A kiválasztási rendezési algoritmusban a válogatott lista tömbjéből a legkisebb elem kerül kiválasztásra, és minden iterációnál a válogatás nélküli lista elejére kerül. Például egy véletlen sorrendben elrendezett számsorban a kiindulási elemet vagy számot választják legalább. A következő lépésben a kiválasztott minimális számot összehasonlítják a következő elemmel vagy számmal. Ha az összehasonlított elem kisebb, mint a kiválasztott minimum, akkor a második elem lesz a minimum. Ez a folyamat az utolsó elemig ismétlődik.

> 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


Kimenet

4. Gyors rendezés

A Quicksort algoritmus ugyanúgy működik, mint az osztás és a szabály. A véletlenszerű elemet egy tömb pivotjává választják, majd az összes többi elemet a pivot kivételével két partícióra osztják. A következő lépésben minden olyan elem, amely kisebb és nagyobb, mint a forgócsapat, két különböző partícióra oszlik. Végül az elemeket rekurzióval rendezzük.

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

Kimenet

5. Rendezés egyesítése

Az merge sort nagyon hasonló a quicksort-hoz, itt a tömb két egyenlő felre van osztva. Az egyesítési rendezési algoritmust két részre osztották: egyesítésre és rendezésre. Egyesítéskor a listákat több al-listára bontják, mindaddig, amíg minden al-lista különálló elemből áll. Az al-listák eredményeinek egyesítése válogatott 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

Kimenet

6. HeapSort

A Heap Sort technika nagyon hasonló a szelekciós rendezéshez, ahol a válogatás nélküli listából a legkisebb elem kerül kiválasztásra az egyes iterációkban és a lista elején. A halomfajta-technika azonban fa fogalmakat használ.

> 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

Kimenet

Következtetés

Ebben a cikkben láttuk, hogyan lehet az R osztályozásával különféle módon osztályozni az adatokat. Láttuk, hogy az adatkeret rendezéséhez hogyan használják a rendezés és a sorrend parancsot. A cikkben a rendezési funkció további korlátozásait mutatták a rendelési funkcióval szemben. A különféle rendezési algoritmusok, mint például a buborék rendezése, a válogatás rendezése és az egyesítés rendezése, részletes magyarázatát alaposan megvitatták. Az osztályozás, mivel ez az adatok elemzésének egyik legfontosabb lépése, eltérő funkciókkal rendelkezik, többszörös igények kielégítésére. Az adatmérnök feladata, hogy a rendelkezésre álló adatok alapján válassza ki a legmegfelelőbb rendezési módszert.

Ajánlott cikkek

Útmutató volt az R. rendezéséhez. Itt tárgyaljuk, mi az R osztályozás, jellemzői és típusai az R. osztályban. A további javasolt cikkeken keresztül további információkat is megtudhat -

1. Adattudományi nyelvek
2. Adatbázis SQL-ben
3. Adattípusok C-ben
4. PostgreSQL adattípusok
5. Bevezetés a rendezésbe a Tableau-ban
6. Beszúrás Rendezés a JavaScript-ben
7. Teljes útmutató a C # szerinti rendezéshez, példákkal
8. Rendezési funkció Python-ban példákkal