Klasse Arrays er en klasse som inneholder statiske metoder som brukes med matriser for å søke, sortere, sammenligne, sette inn elementer eller returnere en strengrepresentasjon av en matrise. Så la oss spesifisere funksjonene først og senere vil vi diskutere det samme. De er som følger tilstede i java.util.Arrays klasse. Her skal vi diskutere forskjellige plott ved hjelp av sort()-metoden til Arrays-klassen .
Arrays.sort()-metoden består av to varianter, en der vi ikke sender noen argumenter der den sorterer ned hele matrisen enten det er heltallsmatrise eller tegnmatrise, men hvis vi skal sortere en spesifikk del ved å bruke denne metoden i Arrays-klassen, vi overbelaster den og sender start- og sisteindeksen til matrisen.
Syntaks: sort() Metode
Arrays.sort();>
Syntaks: Overbelastet sort() Metode
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametere: Det tar tre parametere som kan oppfattes fra syntaksen som er som følger:
- Matrisen som skal sorteres
- Indeksen til det første elementet, inklusive, som skal sorteres (referert til fra_indeks)
- Indeksen til det siste elementet, eksklusive, som skal sorteres (referert til som last_index)
Returtype: AT
Kompleksitetsanalyse:
Tidskompleksitet: O(N log N)
Hjelpeplass: O(1)
La oss nå se implementeringen av sort()-funksjonen på tvers av forskjellige scenarier av Arrays-klassen som følger:
Eksempel 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 +>' '>);> >}> >}> }> |
>
>Produksjon
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Tidskompleksitet: O(nlog(n)) som kompleksiteten til arrays.sort()
Hjelpeplass: O(1)
Eksempel 2:
Java
java-bryter
// 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));> >}> }> |
>
>Produksjon
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Kompleksiteten til metoden ovenfor:
Tidskompleksitet: O(N log N)
Hjelpeplass: O(1)
Eksempel 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));> >}> }> |
>
>Produksjon
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Kompleksiteten til metoden ovenfor:
Tidskompleksitet: O(nlog(n)) som kompleksiteten til arrays.sort()
Hjelpeplass: O(1)
Eksempel 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));> >}> }> |
>
>Produksjon
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Kompleksiteten til metoden ovenfor:
Tidskompleksitet: O(nlog(n)) som kompleksiteten til arrays.sort()
Hjelpeplass: O(1)
Eksempel 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));> >}> }> |
css endre bildestørrelse
>
>Produksjon
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Kompleksiteten til metoden ovenfor:
Tidskompleksitet: O(nlog(n)) som kompleksiteten til arrays.sort()
Hjelpeplass: O(1)
Nå til slutt skal vi implementere sort()-metoden til det fulle, fordi her vil vi erklære våre egne definerte kriterier ved hjelp av Komparatorgrensesnitt .
Eksempel 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]); } }> |
>
>Produksjon
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Kompleksiteten til metoden ovenfor:
Tidskompleksitet: O(nlog(n)) som kompleksiteten til arrays.sort()
Hjelpeplass: O(1)
Huske: Det er en liten forskjell mellom Arrays.sort() vs Collections.sort() . Arrays.sort() fungerer for matriser som også kan være av primitiv datatype. Samlinger .sort() fungerer for objekter Samlinger som ArrayList , LinkedList , etc.
Ved å bruke omvendt rekkefølge: Denne metoden vil sortere matrisen i synkende. I Java Collections gir klassen også omvendt rekkefølge() metode for å sortere matrisen i omvendt leksikografisk rekkefølge. Den analyserer ikke noen parameter fordi statisk metode, så vi kan påkalle den direkte ved å bruke klassenavnet. den vil sortere matriser i stigende rekkefølge etter sort()-metoden etter at omvendt rekkefølge()-metoden vil gi oss den naturlige rekkefølgen og vi vil få den sorterte matrisen i synkende rekkefølge.
Syntaks:
Arrays.sort(a, Collections.reverseOrder());>
Eksempel 7:
Java
datamaskin oppfunnet år
// 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));> >}> }> |
>
>Produksjon
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Kompleksiteten til metoden ovenfor:
Tidskompleksitet: O(nlog(n)) som kompleksiteten til arrays.sort()
Hjelpeplass: O(1)