Masyvų klasė yra klasė, kurioje yra statinių metodų, kurie naudojami su masyvais norint ieškoti, rūšiuoti, palyginti, įterpti elementus arba grąžinti masyvo eilutę. Taigi pirmiausia nurodykime funkcijas, o vėliau apie tai kalbėsime. Jie yra tokie java.util.Arrays klasė. Čia mes aptarsime skirtingus siužetus naudodami Masyvo klasės metodas sort() .
Metodas Arrays.sort() susideda iš dviejų variantų, iš kurių vienas neperduodame jokių argumentų, kur jis surūšiuoja visą masyvą, nesvarbu, ar tai būtų sveikųjų skaičių masyvas, ar simbolių masyvas, bet jei mes turėtume rūšiuoti konkrečią dalį naudodami šį Arrays klasės metodą perkrauname jį ir perduodame pradinį bei paskutinį indeksą į masyvą.
Sintaksė: Rūšiuoti() metodas
Arrays.sort();>
Sintaksė: Perkrautas rūšiavimo() metodas
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parametrai: Tam reikia trijų parametrų, kuriuos galima suprasti iš sintaksės, kuri yra tokia:
- Masyvas, kurį reikia rūšiuoti
- Pirmojo rūšiuojamo elemento (imtinai) indeksas (vadinamas kaip from_index)
- Paskutinio rūšiuojamo elemento, išskirtinio, indeksas (vadinamas kaip last_index)
Grąžinimo tipas: TAI
Sudėtingumo analizė:
Laiko sudėtingumas: O (N log N)
Pagalbinė erdvė: O(1)
Dabar pažiūrėkime, kaip rūšiuoti () funkcija yra įgyvendinama įvairiuose Arrays klasės scenarijuose:
1 pavyzdys:
Java
žemės riešutai vs žemės riešutai
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 +>' '>);> >}> >}> }> |
>
>Išvestis
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Laiko sudėtingumas: O(nlog(n)) kaip masyvų sudėtingumas.sort()
Pagalbinė erdvė: O(1)
2 pavyzdys:
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));> >}> }> |
>
už loop bash
>Išvestis
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Pirmiau nurodyto metodo sudėtingumas:
Laiko sudėtingumas: O (N log N)
Pagalbinė erdvė: O(1)
3 pavyzdys:
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));> >}> }> |
>
>Išvestis
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Pirmiau nurodyto metodo sudėtingumas:
Laiko sudėtingumas: O(nlog(n)) kaip masyvų sudėtingumas.sort()
Pagalbinė erdvė: O(1)java kalbos interviu klausimai
4 pavyzdys:
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));> >}> }> |
>
>Išvestis
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Pirmiau nurodyto metodo sudėtingumas:
Laiko sudėtingumas: O(nlog(n)) kaip masyvų sudėtingumas.sort()
Pagalbinė erdvė: O(1)
5 pavyzdys:
Java
slinkties ratukas neveikia
// 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));> >}> }> |
>
>Išvestis
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Pirmiau nurodyto metodo sudėtingumas:
Laiko sudėtingumas: O(nlog(n)) kaip masyvų sudėtingumas.sort()
Pagalbinė erdvė: O(1)
Galiausiai mes iki galo įgyvendinsime metodą sort(), nes čia mes deklaruosime savo apibrėžtus kriterijus naudodami Palyginimo sąsaja .
6 pavyzdys:
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]); } }> |
>
>Išvestis
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Pirmiau nurodyto metodo sudėtingumas:
Laiko sudėtingumas: O(nlog(n)) kaip masyvų sudėtingumas.sort()
Pagalbinė erdvė: O(1)
Prisiminti: Yra nedidelis skirtumas tarp Arrays.sort() vs Collections.sort() . Arrays.sort() veikia masyvams, kurie taip pat gali būti primityvaus tipo duomenų. Kolekcijos .sort() veikia objektams Kolekcijos kaip ArrayList , LinkedList ir kt.
Naudojant atvirkštinės tvarkos metodą: Šis metodas surūšiuos masyvą mažėjančia tvarka. „Java Collections“ klasėje taip pat pateikiama Atvirkštinė tvarka() būdas rūšiuoti masyvą atvirkštine leksikografine tvarka. Jis neanalizuoja jokio parametro dėl statinio metodo, todėl galime jį iškviesti tiesiogiai naudodami klasės pavadinimą. jis surūšiuos masyvus didėjančia tvarka pagal sort() metodą, po to atvirkštinės tvarkos() metodas suteiks mums natūralią tvarką ir gausime surūšiuotą masyvą mažėjančia tvarka.
Sintaksė:
Arrays.sort(a, Collections.reverseOrder());>
7 pavyzdys:
Java
skaičių abėcėlė
// 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));> >}> }> |
>
>Išvestis
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Pirmiau nurodyto metodo sudėtingumas:
Laiko sudėtingumas: O(nlog(n)) kaip masyvų sudėtingumas.sort()
Pagalbinė erdvė: O(1)