Sortowanie w R - Funkcje i typy sortowania w R z przykładowymi kodami

• Wprowadzenie do sortowania w R.

Wprowadzenie do sortowania w R.

Sortowanie jest jednym z kluczowych aspektów analizy danych. Jest to technika, w której dane są uporządkowane lub posegregowane w określonej kolejności. Dane są sortowane w celu wyodrębnienia wymaganych informacji z zestawu danych. Na przykład układając dane w porządku rosnącym na podstawie klucza daty, tutaj określono kryteria sortowania. Tę operację można łatwo wykonać przy użyciu języka R. W języku R istnieje wiele funkcji sortowania, takich jak sortowanie bąbelkowe i sortowanie selekcyjne. W tym artykule zobaczymy znaczenie różnych funkcji sortujących i wyjaśnimy każdą z nich przykładami.

Sortowanie wykonane w R.

Istnieje wiele sposobów sortowania danych w R. To Analityk danych musi rozważyć najbardziej odpowiednią metodę opartą na strukturze danych. Język R ma wiele funkcji i sposobów sortowania danych, takich jak pakiet sort (), order () i dplyrI ().

O czym należy pamiętać przed posortowaniem danych.

1. Kolejność, w jakiej dane muszą być sortowane rosnąco lub malejąco.
2. Kryteria sortowania wielu kolumn.
3. Brakujące i zduplikowane wartości księgowe podczas sortowania. Analityk decyduje, co należy zrobić z brakującymi i zduplikowanymi wartościami. Przed usunięciem lub zastąpieniem wartości zerowych należy wziąć pod uwagę ogólny wpływ na dane.

Funkcja Sort () w R.

Funkcja sortowania w R służy do sortowania wektora. Domyślnie wartość jest uporządkowana rosnąco. Weźmy przykład kolumny oceny wszystkich uczniów w klasie.

Składnia do sortowania wektora to

“sort (x, decreasing = FALSE)”

Tutaj x odnosi się do wektora, a zmniejszenie należy zastąpić PRAWDĄ, gdy sortowanie należy wykonać w kolejności malejącej. Funkcja sortowania służy do ustawiania wektora liczbowego lub znakowego w żądanej kolejności. Głównym ograniczeniem funkcji sortowania jest to, że nie można jej użyć do sortowania ramki danych. Aby obejść to ograniczenie, używana jest funkcja Order ().

Podstawowy przykład sortowania za pomocą funkcji sort ()

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

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

sort (x)

Wynik

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

Sortowania ramek danych można dokonać za pomocą funkcji order (). Zmienne można łatwo sortować w kolejności rosnącej lub malejącej, jednak funkcja sortowania domyślnie sortuje zmienną rosnąco.

> 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

Uwaga: znak ujemny jest używany przed kolumną Wiek (-df $ Wiek), aby posortować Wiek w kolejności malejącej. Alternatywnie można zastosować argument malejący w tej pozycji. Funkcja porządkowania służy raczej do odwoływania się do indeksu kolumny niż do nazwy kolumny. Na przykład zamiast wieku odniesienie indeksu ramki danych, które byłoby „1”. Pamiętając o wartościach indeksu, zaczynamy od „0”.

W kilku przypadkach może być konieczne sortowanie danych według wielu kryteriów, można to osiągnąć w R za pomocą nazw zmiennych lub numerów indeksów. W poniższym przykładzie wykorzystałem zestaw danych mtcars, który jest dostępny w R. studio.

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

W R alternatywnym sposobem sortowania danych jest użycie pakietu dplyr. Ten pakiet jest bardzo łatwy w użyciu i niezawodny, z dokładnymi dostępnymi instrukcjami.

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

Rodzaje sortowania w R.

R jest wyposażony w wiele algorytmów do przeprowadzania sortowania danych. Poniżej znajdują się różne rodzaje funkcji sortowania. Aby zilustrować różne rodzaje sortowania, zastosowano próbkę 10 liczb losowych z tablicy.

1. Sortowanie bąbelkowe

W tym algorytmie dwie wartości są porównywane obok siebie, a elementy zmieniają swoją pozycję, gdy spełnione są kryteria. Może być rosnący lub malejący. W trybie sortowania bąbelkowego tworzone są pary elementów dostępnych w zmiennej, a elementy są porównywane ze sobą, gdy jeden element jest większy od drugiego, zamieniają się. Proces powtarza się do ostatniego elementu.

> 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

Wynik

2. Wstawianie Sortuj

W algorytmie sortowania wstawianego porównywane są posortowane i nieposortowane elementy, a nieposortowany element jest umieszczany w odpowiednim miejscu po każdej iteracji.

W tym algorytmie zakłada się, że pierwszy element jest sortowany, a drugi element jest przechowywany osobno jako kluczowy element. Posortowany element jest następnie porównywany z kluczem. Jeśli posortowany element jest większy niż element kluczowy, miejsca są zamieniane, a element kluczowy jest pierwszym elementem.

> 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

Wynik

3. Wybór Sortuj

Funkcja sortowania selekcji jest szeroko stosowanym algorytmem sortowania stosowanym w języku R. W tego rodzaju sortowaniu najmniejszy element z nieposortowanej listy jest wypychany na początek listy. W algorytmie sortowania wyboru najmniejszy element z tablicy nieposortowanej listy jest wybierany i umieszczany na początku nieposortowanej listy przy każdej iteracji. Na przykład w rzędzie liczb ułożonych w losowej sekwencji element lub liczba początkowa jest wybierana jako minimum. W następnym kroku wybrana minimalna liczba jest porównywana z następnym elementem lub liczbą. W przypadku, gdy porównywany element jest mniejszy niż nasze wybrane minimum, drugi element staje się minimum. Ten proces jest powtarzany do ostatniego elementu.

> 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


Wynik

4. Szybkie sortowanie

Algorytm Quicksort działa na zasadzie dzielenia i rządzenia. Element losowy jest wybierany jako element przestawny w tablicy, a następnie wszystkie inne elementy oprócz elementu przestawnego są dzielone na dwie partycje. W następnym kroku wszystkie elementy, które są mniejsze i większe od osi przestawnej, są dzielone na dwie różne partycje. Na koniec elementy są sortowane za pomocą rekurencji.

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

Wynik

5. Scal sortowanie

Sortowanie według scalania jest bardzo podobne do sortowania szybkiego, jednak tutaj tablica jest podzielona na dwie równe połowy. Algorytm sortowania scalonego został podzielony na dwie części: scalanie i funkcję sortowania. W trybie sortowania listy lista jest podzielona na wiele podlist, aż każda podlista będzie składać się z pojedynczego elementu. Scalanie wyników tych list podrzędnych jest listą posortowaną.

> 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

Wynik

6. HeapSort

Technika sortowania sterty jest bardzo podobna do tej stosowanej przy sortowaniu selekcji, w której najmniejszy element z nieposortowanej listy jest wybierany w każdej iteracji i umieszczany na początku listy. Jednak technika Heapsort wykorzystuje koncepcje drzew.

> 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

Wynik

Wniosek

W tym artykule widzieliśmy różne sposoby sortowania danych za pomocą R. Widzieliśmy, jak do sortowania ramki danych używane jest polecenie sort i order, w artykule pokazano dalsze ograniczenia funkcji sortowania względem funkcji order. Dokładne wyjaśnienie różnych algorytmów sortowania, takich jak sortowanie bąbelkowe, sortowanie selekcyjne i sortowanie scalone, zostało dokładnie omówione. Sortowanie jest jednym z najważniejszych etapów analizy danych, ma różne funkcje dla wielu potrzeb. Inżynier danych musi wybrać najbardziej odpowiednią metodę sortowania w oparciu o dostępne dane.

Polecane artykuły

To był przewodnik po sortowaniu w R. Tutaj omawiamy, co sortuje w R, funkcje i rodzaje sortowania w R. Możesz również przejrzeć nasze inne sugerowane artykuły, aby dowiedzieć się więcej -

1. Języki nauki danych
2. Baza danych w SQL
3. Typy danych w C
4. Typy danych PostgreSQL
5. Wprowadzenie do sortowania w Tableau
6. Wstawianie Sortuj w JavaScript
7. Kompletny przewodnik po sortowaniu w C # z przykładami
8. Funkcja sortowania w Pythonie z przykładami