Introduction au tri dans R

Le tri est l'un des aspects cruciaux de l'analyse des données. Il s'agit d'une technique dans laquelle les données sont organisées ou séparées dans un ordre spécifique. Les données sont triées afin d'extraire les informations requises de l'ensemble de données. Par exemple, en organisant les données par ordre croissant en fonction de la clé de date, ici des critères ont été spécifiés afin de trier. Cette opération peut être facilement effectuée en utilisant le langage R. En langage R, il existe plusieurs fonctions de tri telles que le tri à bulles et le tri par sélection. Dans cet article, nous verrons l'importance des différentes fonctions de tri et expliquerons chacune d'entre elles avec des exemples.

Tri effectué en R

Il existe plusieurs façons de trier les données dans R. Il appartient à l'analyste de données de considérer la méthode la plus appropriée en fonction de la structure des données. Le langage R a plusieurs fonctions et façons de trier les données telles que le package sort (), order () et dplyrI ().

Éléments à garder à l'esprit avant de trier les données.

  1. Ordre dans lequel les données doivent être triées en ordre croissant ou décroissant.
  2. Critères de tri sur plusieurs colonnes.
  3. Comptabilisation des valeurs manquantes et en double lors du tri. C'est à l'analyste de décider ce qu'il faut faire avec les valeurs manquantes et en double. Avant de supprimer ou de remplacer des valeurs nulles, l'impact global sur les données doit être pris en compte.

Fonction Sort () dans R

La fonction de tri dans R est utilisée pour trier un vecteur. Par défaut, la valeur est organisée par ordre croissant. Prenons un exemple de la colonne de la marque de tous les élèves d'une classe.

La syntaxe pour trier le vecteur est

“sort (x, decreasing = FALSE)”

Ici, x fait référence au vecteur et la diminution doit être remplacée par VRAI lorsque le tri doit être effectué dans l'ordre décroissant. La fonction de tri est utilisée pour organiser le vecteur numérique ou de caractères dans l'ordre souhaité. La principale limitation de la fonction de tri est qu'elle ne peut pas être utilisée pour trier une trame de données. Pour surmonter cette limitation, la fonction Order () est utilisée.

Un exemple de tri basique utilisant la fonction sort ()

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

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

trier (x)

Production

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

Le tri des trames de données peut être effectué à l'aide de la fonction order (). Les variables peuvent être facilement triées dans l'ordre croissant ou décroissant, cependant, la fonction d'ordre triera la variable dans l'ordre croissant par défaut.

> 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

Veuillez noter que le signe négatif est utilisé devant la colonne Âge (-df $ Âge) afin de trier l'âge par ordre décroissant. Alternativement, l'argument descendant peut être utilisé dans cette position. La fonction Ordre est utilisée pour faire référence à l'index de colonne plutôt qu'au nom de la colonne. Par exemple, à la place de l'âge, la référence d'index de la base de données qui serait «1». Gardant à l'esprit les valeurs d'index commencent un «0».

Dans certains cas, nous pourrions avoir besoin de trier les données avec plusieurs critères, cela peut être réalisé dans R à l'aide de noms de variables ou de numéros d'index. Dans l'exemple ci-dessous, j'ai utilisé le jeu de données mtcars qui est disponible dans 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) ), )

Dans R, une autre manière de trier les données consiste à utiliser le package dplyr. Ce package est très facile à utiliser et fiable avec des instructions précises disponibles.

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

Types de tri dans R

R est équipé de plusieurs algorithmes pour effectuer un tri sur les données. Voici les différents types de fonctions de tri. Pour illustrer les différents types de tri, un échantillon de 10 nombres aléatoires d'un tableau est utilisé.

1. Tri des bulles

Dans cet algorithme, deux valeurs sont comparées côte à côte et les éléments échangent leur position lorsque les critères sont remplis. Il peut être croissant ou décroissant. Dans le tri à bulles, des paires sont formées pour les éléments disponibles en variable et les éléments sont comparés les uns aux autres, lorsqu'un élément est supérieur à un autre, ils sont échangés. Le processus est répété jusqu'au dernier élément.

> 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

Production

2. Tri par insertion

Dans l'algorithme de tri par insertion, les éléments triés et non triés sont comparés et l'élément non trié est placé à un endroit approprié après chaque itération.

Dans cet algorithme, le premier élément est supposé être trié et le deuxième élément est stocké séparément en tant qu'élément clé. L'élément trié est ensuite comparé à la clé. Si l'élément trié est supérieur à l'élément clé, les emplacements sont échangés et l'élément clé est le premier élément.

> 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

Production

3. Tri de sélection

La fonction de tri par sélection est un algorithme de tri largement utilisé dans le langage R. Dans ce type de tri, le plus petit élément de la liste non triée est poussé au début de la liste. Dans l'algorithme de tri par sélection, le plus petit élément du tableau de la liste non triée est sélectionné et placé au début de la liste non triée à chaque itération. Par exemple, dans une rangée de nombres disposés dans une séquence aléatoire, l'élément ou le numéro de départ est sélectionné au minimum. Dans l'étape suivante, le nombre minimum sélectionné est comparé à l'élément ou au numéro suivant. Dans le cas où l'élément comparé est plus petit que notre minimum sélectionné, le deuxième élément devient le minimum. Ce processus est répété jusqu'au dernier élément.

> 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

Production

4. Tri rapide

L'algorithme de tri rapide fonctionne comme la division et la règle. L'élément aléatoire est sélectionné comme pivot dans un tableau, puis tous les autres éléments, à l'exception de pivot, sont divisés en deux partitions. Dans l'étape suivante, tous les éléments inférieurs et supérieurs au pivot sont divisés en deux partitions différentes. Enfin, les éléments sont triés par récursivité.

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

Production

5. Tri par fusion

Le tri par fusion est très similaire au tri rapide cependant, ici le tableau est divisé en deux moitiés égales. L'algorithme de tri par fusion a été divisé en deux parties: une fonction de fusion et une fonction de tri. Dans le tri par fusion, une liste est divisée en plusieurs sous-listes jusqu'à ce que chaque sous-liste se compose d'un élément individuel. La fusion de ces résultats de sous-listes est une liste triée.

> 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

Production

6. HeapSort

La technique de tri en tas est très similaire à celle du tri par sélection où le plus petit élément d'une liste non triée est sélectionné à chaque itération et placé au début de la liste. Cependant, la technique heapsort utilise des concepts d'arbre.

> 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

Production

Conclusion

Dans cet article, nous avons vu différentes façons de trier les données à l'aide de R. Nous avons vu comment la commande de tri et d'ordre est utilisée pour trier une trame de données, d'autres limitations de la fonction de tri sur la fonction d'ordre ont été présentées dans l'article. Une explication détaillée des différents algorithmes de tri tels que le tri à bulles, le tri par sélection et le tri par fusion a été discutée en détail. Le tri étant l'une des étapes les plus importantes de l'analyse des données, il a différentes fonctions pour de multiples besoins. Il appartient entièrement à l'ingénieur des données de choisir la méthode de tri la plus appropriée en fonction des données disponibles.

Articles recommandés

Cela a été un guide pour le tri dans R. Ici, nous discutons de ce qu'est le tri dans R, des fonctionnalités et des types de tri dans R. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -

  1. Langages de science des données
  2. Base de données en SQL
  3. Types de données en C
  4. Types de données PostgreSQL
  5. Introduction au tri dans Tableau
  6. Tri par insertion en JavaScript
  7. Guide complet de tri en C # avec des exemples
  8. Fonction de tri en Python avec des exemples

Catégorie:

Big Data