Classe de matrius és una classe que conté mètodes estàtics que s'utilitzen amb matrius per cercar, ordenar, comparar, inserir elements o retornar una representació de cadena d'una matriu. Per tant, especifiquem les funcions primer i després parlarem del mateix. Estan presents de la següent manera java.util.Arrays classe. Aquí parlarem de diferents trames utilitzant el mètode sort() de la classe Arrays .
El mètode Arrays.sort() consta de dues variacions, una en què no passem cap argument on ordena la matriu completa, ja sigui una matriu entera o una matriu de caràcters, però si se suposa que hem d'ordenar una part específica mitjançant aquest mètode de la classe Arrays, aleshores el sobrecarreguem i passem l'índex inicial i l'últim a la matriu.
Sintaxi: Mètode sort().
Arrays.sort();>
Sintaxi: Mètode sort() sobrecarregat
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Paràmetres: Pren tres paràmetres com es pot percebre de la sintaxi que és la següent:
- La matriu que s'ha d'ordenar
- L'índex del primer element, inclòs, que s'ha d'ordenar (anomenat from_index)
- L'índex de l'últim element, exclusiu, a ordenar (anomenat last_index)
Tipus de retorn: AIXÒ
Anàlisi de complexitat:
Complexitat temporal: O(N log N)
Espai auxiliar: O(1)
Ara vegem la implementació de la funció sort() en diferents escenaris de la classe Arrays de la següent manera:
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 +>' '>);> >}> >}> }> |
>
>Sortida
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: 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));> >}> }> |
>
>Sortida
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Complexitat del mètode anterior:
Complexitat temporal: O(N log N)
Espai auxiliar: 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));> >}> }> |
>
>Sortida
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Complexitat del mètode anterior:
Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)
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));> >}> }> |
>
>Sortida
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Complexitat del mètode anterior:
Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: 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));> >}> }> |
>
apilar en java
>Sortida
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Complexitat del mètode anterior:
Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)
Ara, finalment, implementarem el mètode sort() al màxim perquè aquí declararem els nostres propis criteris definits amb l'ajuda del Interfície de comparació .
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]); } }> |
>
>Sortida
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Complexitat del mètode anterior:
Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)
Recordeu: Hi ha una lleugera diferència entre Arrays.sort() vs Collections.sort() . Arrays.sort() funciona per a matrius que també poden ser de tipus de dades primitives. Col·leccions .sort() funciona per a objectes com Col·leccions ArrayList , LinkedList , etc.
Utilitzant el mètode d'ordre invers: Aquest mètode ordenarà la matriu de forma descendent. A les col·leccions de Java, la classe també proporciona ordre invers() mètode per ordenar la matriu en ordre lexicogràfic invers. No analitza cap paràmetre a causa del mètode estàtic, de manera que podem invocar-lo directament utilitzant el nom de la classe. ordenarà les matrius en ordre ascendent pel mètode sort() després d'això, el mètode d'ordre invers () ens donarà l'ordre natural i obtindrem la matriu ordenada en ordre descendent.
Sintaxi:
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));> >}> }> |
>
>Sortida
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Complexitat del mètode anterior:
Complexitat temporal: O(nlog(n)) com a complexitat de arrays.sort()
Espai auxiliar: O(1)