Introducere în Sortarea în R
Sortarea este unul dintre aspectele cruciale ale analizei datelor. Este o tehnică în care datele sunt aranjate sau segregate într-o ordine specifică. Datele sunt sortate pentru a extrage informațiile solicitate din setul de date. De exemplu, aranjarea datelor în ordine crescătoare pe baza tastei date, aici criteriile au fost specificate pentru a sorta. Această operație poate fi realizată cu ușurință folosind limbajul R. În limbajul R există mai multe funcții de sortare, cum ar fi sortarea cu bule și sortarea selecției. În acest articol, vom vedea importanța diferitelor funcții de sortare și vom explica fiecare dintre ele cu exemple.
Sortare Realizată în R
Există mai multe modalități prin care datele pot fi sortate în R. Depinde analistul de date să ia în considerare cea mai potrivită metodă bazată pe structura datelor. Limbajul R are mai multe funcții și modalități de sortare a datelor cum ar fi pachetul sort (), ordine () și dplyrI ().
Lucruri de care trebuie să ții cont înainte de a sorta datele.
- Ordine în care datele trebuie sortate ascendent sau descrescător.
- Criterii de sortare a mai multor coloane.
- Contabilitatea lipsește și duplică valorile în timpul sortării. Depinde analistului să decidă ce trebuie făcut cu valorile lipsă și duplicate. Înainte de a elimina sau înlocui valorile nule, trebuie avut în vedere impactul general asupra datelor.
Funcția Sort () în R
Funcția de sortare în R este utilizată pentru a sorta un vector. În mod implicit, valoarea este organizată în ordine crescătoare. Să luăm un exemplu din coloana de marcă a tuturor elevilor dintr-o clasă.
Sintaxa pentru a sorta vectorul este
“sort (x, decreasing = FALSE)”
Aici x se referă la vector și scăderea trebuie să fie înlocuită cu TRUE atunci când sortarea trebuie făcută în ordine descrescătoare. Funcția de sortare este utilizată la aranjarea vectorului numeric sau al caracterelor în ordinea dorită. Limitarea principală a funcției de sortare este aceea că nu poate fi utilizată pentru a sorta un cadru de date. Pentru a depăși această limitare se utilizează funcția Order ().
Un exemplu de sortare de bază folosind funcția sortare ()
set.seed(1)
x <- sample(1:100, 10)
x
producție
(1) 68 39 1 34 87 43 14 82 59 51
sort (x)
producție
(1) 1 14 34 39 43 51 59 68 82 87Sortarea cadrelor de date se poate realiza cu ajutorul funcției de comandă (). Variabilele pot fi sortate ușor în ordine crescătoare sau descendentă, cu toate acestea, funcția de comandă va sorta variabila în creștere în mod implicit.
> 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
Vă rugăm să rețineți că semnul negativ este utilizat în fața coloanei Age (-df $ Age) pentru a sorta Vârsta în ordine descrescătoare. Alternativ, argumentul descendent poate fi folosit în această poziție. Funcția Comandă este folosită pentru a face referire la indexul coloanelor și nu la numele coloanei. De exemplu, în loc de vârstă, indicele de referință al cadrului de date care ar fi „1”. Reținând valorile indicelui începe un „0”.
În câteva cazuri, este posibil să avem nevoie de a sorta datele cu mai multe criterii, acest lucru poate fi obținut în R cu ajutorul utilizării de nume variabile sau numere de index. În exemplul de mai jos am folosit setul de date mtcars care este disponibil în studioul R.
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) ), )
În R, o modalitate alternativă de a sorta datele este folosind pachetul dplyr. Acest pachet este foarte ușor de utilizat și fiabil, cu instrucțiuni precise.
> install.packages("dplyr")
> library(dplyr)
> df <- mtcars
>
> # sort the dataframe by key disp
> arrange(mydata, disp)
Tipuri de sortare în R
R este echipat cu mai mulți algoritmi pentru a efectua sortarea datelor. Mai jos se prezintă diferitele tipuri de funcții de sortare. Pentru a ilustra diferitele tipuri de sortare, este utilizat un eșantion de 10 numere aleatorii dintr-un tablou.
1. Sortare cu bule
În acest algoritm, două valori sunt comparate cot la cot, iar elementele își schimbă poziția atunci când sunt îndeplinite criteriile. Poate fi fie în ordine ascendentă, fie în ordine descendentă. În sortul de bule se formează perechi pentru elementele disponibile în variabilă, iar elementele sunt comparate între ele, atunci când un element este mai mare decât altul au fost schimbate. Procesul se repetă până la ultimul 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
producție
2. Sortare inserție
În algoritmul de sortare a inserției, elementele sortate și nesortate sunt comparate, iar elementul nesortat este plasat într-un loc potrivit după fiecare iterație.
În acest algoritm se presupune că primul element este sortat și al doilea element este stocat separat ca element cheie. Elementul sortat este apoi comparat cu cheia. Dacă elementul sortat este mai mare decât elementul cheie, locurile sunt schimbate, iar elementul cheie este primul 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
producție
3. Sortare selecție
Funcția de sortare de selecție este un algoritm de sortare pe scară largă utilizat în limbajul R. În acest tip de sortare, cel mai mic element din lista nesortată este împins până la începutul listei. În algoritmul de sortare a selecției, este selectat cel mai mic element din tabloul din lista nesortată și plasat la începutul listei nesortate la fiecare iterație. De exemplu, într-un rând de numere aranjate într-o secvență aleatorie elementul de pornire sau numărul este selectat ca minim. În pasul următor, numărul minim selectat este comparat cu următorul element sau număr. În cazul în care elementul comparat este mai mic decât minimul selectat, cel de-al doilea element devine minim. Acest proces este iterat până la ultimul 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
producție
4. Sortare rapidă
Algoritmul Quicksort funcționează ca divizare și regulă. Elementul aleator este selectat ca pivot într-un tablou și apoi toate celelalte elemente, cu excepția pivotului, sunt împărțite în două partiții. În pasul următor, toate elementele care sunt mai mici și mai mari decât pivotul sunt împărțite în două partiții diferite. În cele din urmă, elementele sunt sortate folosind recursiv.
> # 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
producție
5. Sortare Merge
Sortul de îmbinare este foarte asemănător cu cel al quicksort-ului, aici tabloul este împărțit în două jumătăți egale. Algoritmul de sortare a îmbinării a fost împărțit în două părți, o funcție de îmbinare și sortare. În cadrul sortării de îmbinare, o listă se descompun în mai multe sub-liste până când fiecare sub-listă constă dintr-un element individual. Fuzionarea rezultatelor sub-listelor este o listă sortată.
> 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
producție
6. HeapSort
Tehnica de selectare a haldelor este foarte similară cu cea a sortării de selecție, unde este selectat cel mai mic element dintr-o listă nesortată în fiecare iterație și se plasează la începutul listei. Cu toate acestea, tehnica heapsort folosește concepte de arbore.
> 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
producție
Concluzie
În acest articol, am văzut moduri diferite de a putea fi sortate datele folosind R. Am văzut cum se folosește comanda sortare și comandă pentru sortarea unui cadru de date, alte articole au fost afișate în articol limitări ale funcției de sortare asupra funcției de comandă. O explicație detaliată a diferitor algoritmi de sortare, cum ar fi sortarea bulelor, sortarea selecției și sortarea îmbinărilor a fost discutată în detaliu. Sortarea fiind unul dintre cei mai importanți pași ai analizei datelor, are funcții diferite pentru nevoi multiple. Inginerul de date este în totalitate să aleagă cea mai potrivită metodă de sortare pe baza datelor disponibile.
Articole recomandate
Acesta a fost un ghid pentru Sortarea în R. Aici discutăm ce este sortarea în R, caracteristicile și tipurile de sortare în R. Puteți parcurge și alte articole sugerate pentru a afla mai multe -
- Limbi de știință a datelor
- Baza de date în SQL
- Tipuri de date în C
- Tipuri de date PostgreSQL
- Introducere în Sortare în Tabel
- Sortare inserție în JavaScript
- Ghid complet de sortare în C # cu exemple
- Funcția de sortare în Python cu exemple