Сортиране в R - Функции и видове сортиране в R с кодове за проби

• Въведение в сортирането в R

Въведение в сортирането в R

Сортирането е един от основните аспекти на анализа на данните. Това е техника, при която данните са подредени или разделени в определен ред. Данните са сортирани с цел извличане на необходимата информация от набора от данни. Например, подреждането на данните във възходящ ред въз основа на клавиша за дата, тук са зададени критерии за сортиране. Тази операция може лесно да се извърши с помощта на R език. В R език има множество функции за сортиране като сортиране на балончета и сортиране на селекция. В тази статия ще видим значението на различните функции за сортиране и ще обясним всяка от тях с примери.

Сортиране, извършвано в R

Има няколко начина, чрез които данните могат да бъдат сортирани в R. От анализатора на данните зависи да разгледа най-подходящия метод, основан на структурата на данните. R езикът има множество функции и начини за сортиране на данни като сортиране (), ред () и dplyrI () пакет.

Неща, които трябва да имате предвид, преди да сортирате данните.

1. Ред, в който данните трябва да бъдат сортирани възходящо или низходящо.
2. Критерии за сортиране на няколко колони.
3. Отчитане на липсващи и дублирани стойности по време на сортирането. От аналитика зависи да реши какво трябва да се направи с липсващите и дублиращи се стойности. Преди да премахнете или замените нулевите стойности, трябва да се вземе предвид цялостното въздействие върху данните.

Функция Sort () в R

Функцията за сортиране в R се използва за сортиране на вектор. По подразбиране стойността се организира във възходящ ред. Нека вземем пример с колоната на марки на всички ученици в класната стая.

Синтаксисът за сортиране на вектора е

“sort (x, decreasing = FALSE)”

Тук x се отнася до вектора и намаляването трябва да бъде заменено на ИСТИНСКО, когато сортирането трябва да се извърши в низходящ ред. Функцията за сортиране се използва за подреждане на числов или символен вектор в желания ред. Основното ограничение на функцията за сортиране е, че тя не може да се използва за сортиране на рамка от данни. За преодоляване на това ограничение се използва функция Order ().

Основен пример за сортиране, използващ функция sort ()

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

продукция
(1) 68 39 1 34 87 43 14 82 59 51

сортиране (х)

продукция

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

Сортирането на рамки от данни може да се извърши с помощта на функция order (). Променливите могат лесно да бъдат сортирани във възходящ или низходящ ред, но функцията на поръчка ще сортира променливата във възходяща група по подразбиране.

> 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

Моля, обърнете внимание, че отрицателният знак се използва пред графата Възраст (-df $ Age), за да се сортира възрастта в низходящ ред. Алтернативно, низходящият аргумент може да се използва в тази позиция. Функцията Order се използва за позоваване на индекса на колоната, а не към името на колоната. Например на мястото на възрастта референтният индекс на рамката от данни, който би бил "1". Имайки предвид стойностите на индекса, започвайте с „0“.

В няколко случая може да се наложи да сортираме данните с множество критерии, това може да бъде постигнато в R с помощта на използване на променливи имена или индексни числа. В примера по-долу използвах набора от данни на mtcars, който се предлага в 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) ), )

В R алтернативен начин за сортиране на данните е с помощта на пакет dplyr. Този пакет е много лесен за използване и надежден с налични точни инструкции.

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

Видове сортиране в R

R е оборудван с множество алгоритми за извършване на сортиране на данните. По-долу са описани различните видове функции за сортиране. За илюстриране на различните видове сортиране се използва извадка от 10 произволни числа от масив.

1. Сортиране на балончета

В този алгоритъм две стойности се сравняват един до друг и елементите сменят позицията си, когато критериите са изпълнени. Тя може да бъде във възходящ или низходящ ред. В балонните сортове се образуват двойки за елементи, достъпни в променлива и елементите се сравняват един срещу друг, когато един елемент е по-голям от друг, те се разменят. Процесът се повтаря до последния елемент.

> 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

продукция

2. Сортиране на вмъкване

При алгоритъма за сортиране на вмъкването се сравняват сортирани и несортирани елементи и несортираният елемент се поставя на подходящо място след всяка итерация.

В този алгоритъм се приема, че първият елемент е сортиран, а вторият се съхранява отделно като ключов елемент. След това сортираният елемент се сравнява с ключа. Ако сортираният елемент е по-голям от ключовия елемент, местата се разменят и ключовият елемент е първият елемент.

> 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

продукция

3. Сортиране на селекцията

Функцията за сортиране на селекция е широко използван алгоритъм за сортиране, използван в езика R. При този тип сортиране най-малкият елемент от несортирания списък се изтласква до началото на списъка. В алгоритъма за сортиране на селекцията се избира най-малкият елемент от масива на несортирания списък и се поставя в началото на несортирания списък при всяка итерация. Например, в редица числа, подредени в произволна последователност, началният елемент или число е избран като минимум. В следващата стъпка избраният минимален брой се сравнява със следващия елемент или число. В случай, че сравнения елемент е по-малък от избрания ни минимум, вторият елемент става минималният. Този процес се повтаря до последния елемент.

> 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


продукция

4. Бързо сортиране

Quicksort алгоритъмът работи като разделяне и управление. Случайният елемент е избран като въртящ се в масив и след това всички други елементи, с изключение на въртене, се разделят на два дяла. В следващата стъпка всички елементи, които са по-малки и по-големи от въртенето, се разделят на два различни дяла. Накрая, елементите са сортирани с помощта на рекурсия.

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

продукция

5. Сливане на сортиране

Сливането сортиране е много подобно на quicksort, но тук масивът е разделен на две равни половини. Алгоритъмът за сортиране на сливане е разделен на две части функция за сливане и сортиране. При сортиране на сливане списък се разбива на множество под-списъци, докато всеки под-списък се състои от отделен елемент. Обединяването на резултатите от тези под-списъци е сортиран списък.

> 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

продукция

6. HeapSort

Техниката за сортиране на Heap е много подобна на тази за сортиране на селекция, при която най-малкият елемент от несортиран списък е избран при всяка итерация и се поставя в началото на списъка. Въпреки това, техниката на купчина използва концепции за дърво.

> 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

продукция

заключение

В тази статия видяхме различни начини, по които данните могат да бъдат сортирани с помощта на R. Видяхме как командата за сортиране и поръчка се използва за сортиране на кадър от данни, в статията са показани допълнителни ограничения на функцията за сортиране спрямо функцията за поръчка. Подробно обяснение на различни алгоритми за сортиране като сортиране на мехурчета, сортиране на селекция и сортиране на сливане е подробно обсъдено. Сортирането е една от най-важните стъпки за анализ на данни, има различни функции за множество нужди. Инженерът на данни зависи изцяло от избора на най-подходящия метод за сортиране въз основа на наличните данни.

Препоръчителни статии

Това е ръководство за сортиране в R. Тук обсъждаме какво е сортирането в R, характеристики и типове сортиране в R. Можете също да прегледате и другите ни предложени статии, за да научите повече -

1. Езици на науката за данни
2. База данни в SQL
3. Типове данни в С
4. Типове данни PostgreSQL
5. Въведение в сортирането в Tableau
6. Сортиране на вмъкване в JavaScript
7. Пълно ръководство за сортиране в C # с примери
8. Функция за сортиране в Python с примери