Classe de tableaux est une classe contenant des méthodes statiques utilisées avec des tableaux afin de rechercher, trier, comparer, insérer des éléments ou renvoyer une représentation sous forme de chaîne d'un tableau. Précisons donc d’abord les fonctions et nous en discuterons plus tard. Ils sont les suivants étant présents dans java.util.Arrays classe. Ici, nous discuterons de différentes parcelles en utilisant le Méthode sort() de la classe Arrays .
La méthode Arrays.sort() se compose de deux variantes : l'une dans laquelle nous ne transmettons aucun argument où elle trie le tableau complet, qu'il s'agisse d'un tableau d'entiers ou d'un tableau de caractères, mais si nous sommes censés trier une partie spécifique en utilisant cette méthode de la classe Arrays, alors nous le surchargeons et passons l'index de début et du dernier au tableau.
Syntaxe: Méthode sort()
Arrays.sort();>
Syntaxe: Méthode sort() surchargée
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Paramètres: Il faut trois paramètres comme le montre la syntaxe qui est la suivante :
- Le tableau à trier
- L'index du premier élément, inclus, à trier (appelé from_index)
- L'index du dernier élément, exclusif, à trier (appelé last_index)
Type de retour : QUE
Analyse de complexité :
Complexité temporelle : O(N log N)
Espace auxiliaire : O(1)
Voyons maintenant l'implémentation de la fonction sort() dans différents scénarios de la classe Arrays comme suit :
Exemple 1:
Java
import> java.util.Arrays;> class> GFG {> >public> static> void> main(String args[])> >{> >int>[] arr = {>5>, ->2>,>23>,>7>,>87>, ->42>,>509> };> >System.out.println(>'The original array is: '>);> >for> (>int> num : arr) {> >System.out.print(num +>' '>);> >}> >Arrays.sort(arr);> >System.out.println(>'
The sorted array is: '>);> >for> (>int> num : arr) {> >System.out.print(num +>' '>);> >}> >}> }> |
>
>Sortir
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Complexité temporelle : O(nlog(n)) selon la complexité des tableaux.sort()
Espace Auxiliaire : O(1)
Exemple 2 :
Java
// Java Program to Sort Array of Integers> // by Default Sorts in an Ascending Order> // using Arrays.sort() Method> // Importing Arrays class from the utility class> import> java.util.Arrays;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Custom input array> >int>[] arr = {>13>,>7>,>6>,>45>,>21>,>9>,>101>,>102> };> >// Applying sort() method over to above array> >// by passing the array as an argument> >Arrays.sort(arr);> >// Printing the array after sorting> >System.out.println(>'Modified arr[] : '> >+ Arrays.toString(arr));> >}> }> |
>
>Sortir
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(N log N)
Espace auxiliaire : O(1)
Exemple 3 :
Java
// Java program to Sort a Subarray in Array> // Using Arrays.sort() method> // Importing Arrays class from java.util package> import> java.util.Arrays;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Custom input array> >// It contains 8 elements as follows> >int>[] arr = {>13>,>7>,>6>,>45>,>21>,>9>,>2>,>100> };> >// Sort subarray from index 1 to 4, i.e.,> >// only sort subarray {7, 6, 45, 21} and> >// keep other elements as it is.> >Arrays.sort(arr,>1>,>5>);> >// Printing the updated array which is> >// sorted after 2 index inclusive till 5th index> >System.out.println(>'Modified arr[] : '> >+ Arrays.toString(arr));> >}> }> |
>
>Sortir
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(nlog(n)) selon la complexité des tableaux.sort()
Espace Auxiliaire : O(1)gimp remplacer la couleur
Exemple 4 :
Java
// Java program to Sort a Subarray in Descending order> // Using Arrays.sort()> // Importing Collections class and arrays classes> // from java.util package> import> java.util.Arrays;> import> java.util.Collections;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Note that we have Integer here instead of> >// int[] as Collections.reverseOrder doesn't> >// work for primitive types.> >Integer[] arr = {>13>,>7>,>6>,>45>,>21>,>9>,>2>,>100> };> >// Sorts arr[] in descending order using> >// reverseOrder() method of Collections class> >// in Array.sort() as an argument to it> >Arrays.sort(arr, Collections.reverseOrder());> >// Printing the array as generated above> >System.out.println(>'Modified arr[] : '> >+ Arrays.toString(arr));> >}> }> |
concaténation SQL
>
>Sortir
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(nlog(n)) selon la complexité des tableaux.sort()
Espace Auxiliaire : O(1)
Exemple 5 :
Java
// Java program to sort an array of strings> // in ascending and descending alphabetical order> // Using Arrays.sort()> // Importing arrays and Collections class> // from java.util class> import> java.util.Arrays;> import> java.util.Collections;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Custom input string> >String arr[] = {>'practice .techcodeview.com>,> >'www .techcodeview.com>,> >'code .techcodeview.com> };> >// Sorts arr[] in ascending order> >Arrays.sort(arr);> >System.out.println(>'Modified arr[] : '> >+ Arrays.toString(arr));> >// Sorts arr[] in descending order> >Arrays.sort(arr, Collections.reverseOrder());> >// Lastly printing the above array> >System.out.println(>'Modified arr[] :'> >+ Arrays.toString(arr));> >}> }> |
>
>Sortir
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(nlog(n)) selon la complexité des tableaux.sort()
Espace Auxiliaire : O(1)
Enfin, nous allons implémenter la méthode sort() au maximum car ici nous déclarerons nos propres critères définis à l'aide du Interface du comparateur .
Exemple 6 :
Java
// Java program to demonstrate Working of> // Comparator interface> // Importing required classes> import> java.io.*;> import> java.lang.*;> import> java.util.*;> // Class 1> // A class to represent a student.> class> Student {> >int> rollno;> >String name, address;> >// Constructor> >public> Student(>int> rollno, String name, String address)> >{> >// This keyword refers to current object itself> >this>.rollno = rollno;> >this>.name = name;> >this>.address = address;> >}> >// Used to print student details in main()> >public> String toString()> >{> >return> this>.rollno +>' '> +>this>.name +>' '> >+>this>.address;> >}> }> // Class 2> // Helper class extending Comparator interface> class> Sortbyroll>implements> Comparator {> >// Used for sorting in ascending order of> >// roll number> >public> int> compare(Student a, Student b)> >{> >return> a.rollno - b.rollno;> >}> }> // Class 3> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >Student[] arr> >= {>new> Student(>111>,>'bbbb'>,>'london'>),> >new> Student(>131>,>'aaaa'>,>'nyc'>),> >new> Student(>121>,>'cccc'>,>'jaipur'>) };> >System.out.println(>'Unsorted'>);> >for> (>int> i =>0>; i System.out.println(arr[i]); // Sorting on basic as per class 1 created // (user-defined) Arrays.sort(arr, new Sortbyroll()); System.out.println('
Sorted by rollno'); for (int i = 0; i System.out.println(arr[i]); } }> |
>
>Sortir
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(nlog(n)) selon la complexité des tableaux.sort()
Espace Auxiliaire : O(1)
Souviens-toi: Il y a une légère différence entre Arrays.sort() et Collections.sort() . Arrays.sort() fonctionne pour les tableaux qui peuvent également être de type de données primitif. Collections .sort() fonctionne pour les objets Collections comme Liste des tableaux , Liste liée , etc.
En utilisant la méthode de l'ordre inverse : Cette méthode triera le tableau par ordre décroissant. Dans Java Collections, la classe fournit également le ordre inverse() méthode pour trier le tableau dans l’ordre lexicographique inversé. Il n'analyse aucun paramètre en raison de la méthode statique, nous pouvons donc l'invoquer directement en utilisant le nom de la classe. il triera les tableaux dans l'ordre croissant par la méthode sort(), après quoi la méthode reverse order() nous donnera l'ordre naturel et nous obtiendrons le tableau trié dans l'ordre décroissant.
Syntaxe:
Arrays.sort(a, Collections.reverseOrder());>
Exemple 7 :
Java
// This will sort the array in the descending order> /*package whatever //do not write package name here */> import> java.util.Arrays;> import> java.util.Collections;> public> class> GFG {> >public> static> void> main(String[] args)> >{> >Integer[] array> >= {>99>,>12>, ->8>,>12>,>34>,>110>,>0>,>121>,>66>, ->110> };> >Arrays.sort(array, Collections.reverseOrder());> >System.out.println(> >'Array in descending order: '> >+ Arrays.toString(array));> >}> }> |
>
>Sortir
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(nlog(n)) selon la complexité des tableaux.sort()
Espace Auxiliaire : O(1)