Třídění v R - Funkce a typy třídění v R s ukázkovými kódy

• Úvod do třídění v R

Úvod do třídění v R

Třídění je jedním z klíčových aspektů analýzy dat. Je to technika, ve které jsou data uspořádána nebo segregována v určitém pořadí. Data jsou řazena za účelem získání požadovaných informací z datové sady. Například uspořádáním dat ve vzestupném pořadí na základě klíče data byla zde zadána kritéria pro třídění. Tuto operaci lze snadno provést pomocí jazyka R. V jazyce R existují různé funkce třídění, například třídění bublin a výběr. V tomto článku uvidíme důležitost různých třídicích funkcí a vysvětlíme každou z nich příklady.

Třídění provedeno v R

Existuje několik způsobů, jak lze data třídit v R. Je na analytikovi dat, aby zvážil nejvhodnější metodu založenou na struktuře dat. Jazyk R má několik funkcí a způsobů třídění dat, jako je balíček sort (), order () a dplyrI ().

Před tříděním dat je třeba mít na paměti.

1. Pořadí, ve kterém je třeba data seřadit vzestupně nebo sestupně.
2. Kritéria třídění více sloupců.
3. Účtování chybí a duplicitní hodnoty během třídění. Je na analytiku, aby rozhodl, co je třeba udělat s chybějícími a duplicitními hodnotami. Před odstraněním nebo nahrazením nulových hodnot by měl být zvážen celkový dopad na údaje.

Funkce sort () v R

Funkce třídění v R se používá k třídění vektorů. Ve výchozím nastavení je hodnota uspořádána vzestupně. Vezměme si příklad sloupce značky všech studentů ve třídě.

Syntaxe třídění vektoru je

“sort (x, decreasing = FALSE)”

Zde x označuje vektor a snižování musí být nahrazeno PRAVDA, pokud je třídění provedeno v sestupném pořadí. Funkce řazení se používá při uspořádání číselného nebo znakového vektoru v požadovaném pořadí. Hlavní omezení funkce třídění spočívá v tom, že nelze použít k třídění datového rámce. K překonání tohoto omezení se používá funkce Order ().

Základní příklad řazení pomocí funkce sort ()

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

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

řadit (x)

Výstup

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

Třídění datových rámců lze provést pomocí funkce order (). Proměnné lze snadno třídit ve vzestupném nebo sestupném pořadí, funkce order však ve výchozím nastavení třídí proměnnou vzestupně.

> 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

Vezměte prosím na vědomí, že před sloupcem Age (-df $ Age) se používá záporné znaménko, aby se věk setřídil sestupně. Alternativně lze v této pozici použít sestupný argument. Funkce Order se používá k označení indexu sloupce, nikoli názvu sloupce. Například namísto věku by měl být indexový odkaz na datový rámec „1“. Mějte na paměti, že hodnoty indexu začínají „0“.

V několika případech může být nutné data třídit podle několika kritérií, čehož lze dosáhnout v R pomocí názvů proměnných nebo indexových čísel. V níže uvedeném příkladu jsem použil datový soubor mtcars, který je k dispozici ve studiu 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) ), )

V R je alternativní způsob třídění dat pomocí balíčku dplyr. Tento balíček je velmi snadno použitelný a spolehlivý s dostupnými přesnými pokyny.

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

Druhy třídění v R

R je vybaven více algoritmy pro provádění třídění na datech. Níže jsou uvedeny různé typy třídicích funkcí. Pro ilustraci různých typů třídění se používá vzorek 10 náhodných čísel z pole.

1. Řazení bublin

V tomto algoritmu jsou porovnávány dvě hodnoty vedle sebe a prvky vyměňují svou polohu, když jsou kritéria splněna. Může být vzestupně nebo sestupně. V bublinovém třídění jsou vytvořeny páry pro prvky dostupné v proměnné a prvky jsou porovnávány proti sobě, když je jeden prvek větší než druhý, vyměnili se. Proces se opakuje až do posledního prvku.

> 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ýstup

2. Vložení řazení

V algoritmu řazení se porovnávají tříděné a netříděné prvky a netříděný prvek je po každé iteraci umístěn na vhodné místo.

V tomto algoritmu se předpokládá, že první prvek je tříděn a druhý prvek je uložen samostatně jako klíčový prvek. Seřazený prvek je poté porovnán s klíčem. Pokud je tříděný prvek větší než klíčový prvek, jsou místa zaměněna a klíčový prvek je první prvek.

> 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ýstup

3. Výběr řazení

Funkce třídění výběru je široce používaný algoritmus třídění používaný v jazyce R. V tomto typu třídění se nejmenší prvek z netříděného seznamu posune na začátek seznamu. V algoritmu třídění výběru je vybrán nejmenší prvek z pole netříděného seznamu a umístěn na začátek netříděného seznamu při každé iteraci. Například v řadě čísel uspořádaných v náhodném pořadí je jako minimální vybrán počáteční prvek nebo číslo. V dalším kroku se vybraný minimální počet porovná s dalším prvkem nebo číslem. V případě, že porovnávaný prvek je menší než naše vybrané minimum, druhý prvek se stává minimem. Tento proces se opakuje až do posledního prvku.

> 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ýstup

4. Rychlé řazení

Algoritmus Quicksort funguje jako rozdělení a pravidlo. Náhodný prvek je vybrán jako pivot v poli a všechny ostatní prvky kromě pivotu jsou rozděleny do dvou oddílů. V dalším kroku jsou všechny prvky, které jsou menší než a větší než čep, rozděleny do dvou různých oddílů. Nakonec jsou prvky tříděny pomocí rekurze.

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

5. Sloučit řazení

Sloučit řazení je velmi podobné rychlému třídění, zde je však pole rozděleno na dvě stejné poloviny. Algoritmus sloučení řazení byl rozdělen do dvou částí, sloučení a funkce řazení. Při sloučení se seznam rozdělí do několika pod-seznamů, dokud se každý pod-seznam skládá z jednotlivého prvku. Sloučení těchto výsledků podsestav je seřazený seznam.

> 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ýstup

6. HeapSort

Technika třídění haldy je velmi podobná technice výběru třídění, kde je v každé iteraci vybrán nejmenší prvek z netříděného seznamu a umístí se na začátek seznamu. Technika haldy však používá stromové koncepty.

> 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ýstup

Závěr

V tomto článku jsme viděli různé způsoby, jak lze data třídit pomocí R. Viděli jsme, jak se příkaz třídění a řazení používá k třídění datového rámce, v článku byla uvedena další omezení funkce třídění nad funkcí pořadí. Podrobné vysvětlení různých třídicích algoritmů, jako je třídění bublin, výběr a třídění sloučení, bylo důkladně diskutováno. Třídění je jedním z nejdůležitějších kroků analýzy dat a má různé funkce pro více potřeb. Je zcela na datovém inženýrovi, aby vybral nejvhodnější metodu třídění na základě dostupných dat.

Doporučené články

Toto je průvodce tříděním v R. Zde diskutujeme o tom, co je třídění v R, funkcích a druzích třídění v R. Další informace naleznete také v našich dalších navrhovaných článcích -

1. Jazyky vědy o údajích
2. Databáze v SQL
3. Typy dat v C
4. Datové typy PostgreSQL
5. Úvod do třídění v Tableau
6. Vložení Seřadit v JavaScriptu
7. Kompletní průvodce tříděním v C # s příklady
8. Funkce třídění v Pythonu s příklady