Masīvu klase ir klase, kas satur statiskas metodes, kuras tiek izmantotas ar masīviem, lai meklētu, kārtotu, salīdzinātu, ievietotu elementus vai atgrieztu masīva virknes attēlojumu. Tāpēc vispirms precizēsim funkcijas, un vēlāk mēs apspriedīsim to pašu. Tie ir šādi java.util.Arrays klasē. Šeit mēs apspriedīsim dažādus sižetus, izmantojot Arrays klases metode sort() .
Metode Arrays.sort() sastāv no diviem variantiem, kurā mēs nenododam nevienu argumentu, kur tā sakārtotu visu masīvu, vai tas būtu veselu skaitļu masīvs vai rakstzīmju masīvs, bet, ja mums ir paredzēts kārtot noteiktu daļu, izmantojot šo Arrays klases metodi, tad mēs to pārslogojam un nododam sākuma un pēdējo indeksu masīvam.
Sintakse: sort() metode
Arrays.sort();>
Sintakse: Pārslodzes šķirošanas() metode
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametri: Tam nepieciešami trīs parametri, ko var uztvert no sintakses, kas ir šāda:
- Kārtojamais masīvs
- Pirmā kārtojamā elementa indekss (ieskaitot) (saukts par from_index)
- Pēdējā kārtojamā elementa indekss, ekskluzīvs (saukts par last_index)
Atgriešanas veids: TAS
Sarežģītības analīze:
Laika sarežģītība: O(N log N)
Palīgtelpa: O(1)
Tagad aplūkosim funkcijas sort () ieviešanu dažādos klases Arrays scenārijos šādi:
1. piemērs:
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 +>' '>);> >}> >}> }> |
>
>Izvade
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Laika sarežģītība: O(nlog(n)) kā masīvu sarežģītība.sort()
Palīgtelpa: O(1)
2. piemērs:
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));> >}> }> |
>
>Izvade
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Iepriekš minētās metodes sarežģītība:
Laika sarežģītība: O(N log N)
Palīgtelpa: O(1)
3. piemērs:
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));> >}> }> |
>
>Izvade
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Iepriekš minētās metodes sarežģītība:
Laika sarežģītība: O(nlog(n)) kā masīvu sarežģītība.sort()
Palīgtelpa: O(1)
4. piemērs:
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));> >}> }> |
>
>Izvade
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Iepriekš minētās metodes sarežģītība:
Laika sarežģītība: O(nlog(n)) kā masīvu sarežģītība.sort()
Palīgtelpa: O(1)
5. piemērs:
Java
pyspark
// 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));> >}> }> |
>
>Izvade
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Iepriekš minētās metodes sarežģītība:
Laika sarežģītība: O(nlog(n)) kā masīvu sarežģītība.sort()
Palīgtelpa: O(1)
Visbeidzot, mēs pilnībā ieviesīsim sort() metodi, jo šeit mēs deklarēsim savus definētos kritērijus, izmantojot Salīdzinājuma interfeiss .
6. piemērs:
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]); } }> |
>
>Izvade
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Iepriekš minētās metodes sarežģītība:
Laika sarežģītība: O(nlog(n)) kā masīvu sarežģītība.sort()
Palīgtelpa: O(1)
Atcerieties: Pastāv neliela atšķirība starp Arrays.sort() vs Collections.sort() . Arrays.sort() darbojas masīviem, kuriem var būt arī primitīvs datu tips. Kolekcijas .sort() darbojas objektiem, piemēram, kolekcijām ArrayList , LinkedList utt.
Izmantojot apgrieztās secības metodi: Šī metode kārtos masīvu dilstošā secībā. In Java Collections klase nodrošina arī apgrieztā secībā() metode masīva kārtošanai apgrieztā leksikogrāfiskā secībā. Tas neparsē nevienu parametru statiskās metodes dēļ, tāpēc mēs varam to izsaukt tieši, izmantojot klases nosaukumu. tā sakārtos masīvus augošā secībā, izmantojot metodi sort () pēc tam apgrieztā secības () metode mums piešķirs dabisko secību, un mēs iegūsim sakārtoto masīvu dilstošā secībā.
Sintakse:
Arrays.sort(a, Collections.reverseOrder());>
7. piemērs:
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));> >}> }> |
>
>Izvade
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Iepriekš minētās metodes sarežģītība:
Laika sarežģītība: O(nlog(n)) kā masīvu sarežģītība.sort()
Palīgtelpa: O(1)