Einführung in das Sortieren in R
Das Sortieren ist einer der entscheidenden Aspekte der Datenanalyse. Es ist eine Technik, bei der Daten in einer bestimmten Reihenfolge angeordnet oder getrennt werden. Die Daten werden sortiert, um die erforderlichen Informationen aus dem Datensatz zu extrahieren. Wenn Sie beispielsweise die Daten auf der Grundlage des Datumsschlüssels in aufsteigender Reihenfolge anordnen, wurden hier Kriterien zum Sortieren angegeben. Diese Operation kann einfach mit der R-Sprache ausgeführt werden. In der R-Sprache gibt es mehrere Sortierfunktionen wie Blasensortierung und Auswahlsortierung. In diesem Artikel werden wir die Bedeutung verschiedener Sortierfunktionen erkennen und anhand von Beispielen erläutern.
Sortierung durchgeführt in R
Es gibt mehrere Möglichkeiten, wie Daten in R sortiert werden können. Es ist Sache des Datenanalysten, die am besten geeignete Methode basierend auf der Struktur der Daten zu ermitteln. R language hat mehrere Funktionen und Möglichkeiten, die Daten zu sortieren, z. B. sort (), order () und dplyrI ().
Beachten Sie die folgenden Punkte, bevor Sie die Daten sortieren.
- Reihenfolge, in der die Daten auf- oder absteigend sortiert werden müssen.
- Sortierkriterien für mehrere Spalten.
- Fehlende und doppelte Werte beim Sortieren berücksichtigen. Der Analyst muss entscheiden, was mit den fehlenden und doppelten Werten geschehen soll. Vor dem Entfernen oder Ersetzen von Nullwerten sollten die allgemeinen Auswirkungen auf die Daten berücksichtigt werden.
Sort () - Funktion in R
Die Sortierfunktion in R dient zum Sortieren eines Vektors. Standardmäßig ist der Wert in aufsteigender Reihenfolge angeordnet. Nehmen wir ein Beispiel für die Markensäule aller Schüler in einem Klassenzimmer.
Die Syntax zum Sortieren des Vektors lautet
“sort (x, decreasing = FALSE)”
Hier bezieht sich x auf den Vektor und die Abnahme muss auf TRUE ersetzt werden, wenn die Sortierung in absteigender Reihenfolge erfolgen soll. Die Sortierfunktion wird zum Anordnen von Zahlen- oder Zeichenvektoren in der gewünschten Reihenfolge verwendet. Die Hauptbeschränkung der Sortierfunktion besteht darin, dass sie nicht zum Sortieren eines Datenrahmens verwendet werden kann. Um diese Einschränkung zu überwinden, wird die Funktion Order () verwendet.
Ein einfaches Beispiel für die Sortierung mit der Funktion sort ()
set.seed(1)
x <- sample(1:100, 10)
x
Ausgabe
(1) 68 39 1 34 87 43 14 82 59 51
sortieren (x)
Ausgabe
(1) 1 14 34 39 43 51 59 68 82 87Das Sortieren von Datenrahmen kann mit Hilfe der order () -Funktion durchgeführt werden. Variablen können einfach in aufsteigender oder absteigender Reihenfolge sortiert werden. Die Sortierfunktion sortiert die Variable jedoch standardmäßig in aufsteigender Reihenfolge.
> 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
Bitte beachten Sie, dass vor der Spalte Alter ein negatives Vorzeichen (-df $ Age) steht, um das Alter in absteigender Reihenfolge zu sortieren. Alternativ kann das absteigende Argument an dieser Position verwendet werden. Die Order-Funktion wird verwendet, um auf den Spaltenindex und nicht auf den Namen der Spalte zu verweisen. Zum Beispiel anstelle des Alters die Indexreferenz des Datenrahmens, die "1" wäre. Unter Berücksichtigung der Indexwerte beginnt eine „0“.
In einigen Fällen müssen wir die Daten möglicherweise nach mehreren Kriterien sortieren. Dies kann in R mithilfe von Variablennamen oder Indexnummern erreicht werden. Im folgenden Beispiel habe ich den mtcars-Datensatz verwendet, der in R Studio verfügbar ist.
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) ), )
In R besteht eine alternative Möglichkeit zum Sortieren der Daten in der Verwendung von dplyr package. Dieses Paket ist sehr einfach zu bedienen und zuverlässig mit genauen Anweisungen zur Verfügung.
> install.packages("dplyr")
> library(dplyr)
> df <- mtcars
>
> # sort the dataframe by key disp
> arrange(mydata, disp)
Sortierarten in R
R ist mit mehreren Algorithmen zum Sortieren der Daten ausgestattet. Nachfolgend sind die verschiedenen Arten der Sortierfunktion aufgeführt. Um die verschiedenen Arten der Sortierung zu veranschaulichen, wird eine Stichprobe von 10 Zufallszahlen aus einem Array verwendet.
1. Bubble Sort
Bei diesem Algorithmus werden zwei Werte nebeneinander verglichen und Elemente tauschen ihre Position, wenn die Kriterien erfüllt sind. Es kann entweder aufsteigend oder absteigend sein. Bei der Blasensortierung werden Paare für Elemente gebildet, die in Variablen verfügbar sind, und Elemente werden miteinander verglichen, wenn ein Element größer als ein anderes ist, und sie werden vertauscht. Der Vorgang wird bis zum letzten Element wiederholt.
> 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
Ausgabe
2. Insertion Sort
Beim Einfügesortierungsalgorithmus werden sortierte und unsortierte Elemente verglichen und das unsortierte Element nach jeder Iteration an einer geeigneten Stelle platziert.
Bei diesem Algorithmus wird davon ausgegangen, dass das erste Element sortiert ist, und das zweite Element wird separat als Schlüsselelement gespeichert. Das sortierte Element wird dann mit dem Schlüssel verglichen. Wenn das sortierte Element größer als das Schlüsselelement ist, werden die Stellen vertauscht und das Schlüsselelement ist das erste 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
Ausgabe
3. Auswahl sortieren
Die Auswahlsortierfunktion ist ein weit verbreiteter Sortieralgorithmus, der in der R-Sprache verwendet wird. Bei dieser Art der Sortierung wird das kleinste Element aus der unsortierten Liste an den Listenanfang verschoben. Im Auswahlsortieralgorithmus wird das kleinste Element aus dem Array der unsortierten Liste ausgewählt und bei jeder Iteration an den Anfang der unsortierten Liste gesetzt. Beispielsweise wird in einer Reihe von Zahlen, die in einer zufälligen Reihenfolge angeordnet sind, mindestens ein Startelement oder eine Startnummer ausgewählt. Im nächsten Schritt wird die ausgewählte Mindestanzahl mit dem nächsten Element oder der nächsten Zahl verglichen. Ist das verglichene Element kleiner als unser ausgewähltes Minimum, wird das zweite Element zum Minimum. Dieser Vorgang wird bis zum letzten Element wiederholt.
> 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
Ausgabe
4. Schnelle Sortierung
Der Quicksort-Algorithmus funktioniert wie Teilen und Regeln. Das zufällige Element wird als Pivot in einem Array ausgewählt und alle anderen Elemente außer Pivot werden in zwei Partitionen unterteilt. Im nächsten Schritt werden alle Elemente, die kleiner und größer als der Drehpunkt sind, in zwei verschiedene Partitionen unterteilt. Zuletzt werden die Elemente rekursiv sortiert.
> # 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
Ausgabe
5. Sortieren zusammenführen
Merge Sort ist Quicksort sehr ähnlich, hier ist das Array jedoch in zwei gleiche Hälften geteilt. Der Sortieralgorithmus für das Zusammenführen wurde in zwei Teile unterteilt, eine Zusammenführungs- und eine Sortierfunktion. Bei der Zusammenführungssortierung wird eine Liste in mehrere Unterlisten unterteilt, bis jede Unterliste aus einem einzelnen Element besteht. Das Zusammenführen dieser Unterlistenergebnisse ist eine sortierte Liste.
> 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
Ausgabe
6. HeapSort
Die Technik der Heap-Sortierung ist der Auswahlsortierung sehr ähnlich, bei der das kleinste Element aus einer nicht sortierten Liste in jeder Iteration ausgewählt wird und am Anfang der Liste steht. Die Heapsort-Technik verwendet jedoch Baumkonzepte.
> 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
Ausgabe
Fazit
In diesem Artikel haben wir verschiedene Möglichkeiten gesehen, wie Daten mit R sortiert werden können. Wir haben gesehen, wie der Befehl sort and order zum Sortieren eines Datenrahmens verwendet wird. Weitere Einschränkungen der Sortierfunktion gegenüber der Sortierfunktion wurden im Artikel gezeigt. Eine ausführliche Erläuterung der verschiedenen Sortieralgorithmen wie Blasensortierung, Auswahlsortierung und Zusammenführungssortierung wurde eingehend erörtert. Die Sortierung ist einer der wichtigsten Schritte der Datenanalyse und hat unterschiedliche Funktionen für unterschiedliche Anforderungen. Es liegt ganz im Ermessen des Dateningenieurs, die am besten geeignete Methode für die Sortierung basierend auf den verfügbaren Daten auszuwählen.
Empfohlene Artikel
Dies ist eine Anleitung zum Sortieren in R. Hier wird erläutert, was Sortieren in R, Funktionen und Sortierarten in R ist. Sie können auch unsere anderen Artikelvorschläge durchgehen, um weitere Informationen zu erhalten.
- Data Science Languages
- Datenbank in SQL
- Datentypen in C
- PostgreSQL-Datentypen
- Einführung in das Sortieren in Tableau
- Einfügesortierung in JavaScript
- Komplette Anleitung zum Sortieren in C # mit Beispielen
- Sortierfunktion in Python mit Beispielen