clase de matrices es una clase que contiene métodos estáticos que se utilizan con matrices para buscar, ordenar, comparar, insertar elementos o devolver una representación de cadena de una matriz. Entonces, especifiquemos las funciones primero y luego discutiremos lo mismo. Son los siguientes estando presentes en java.util.Arrays clase. Aquí discutiremos diferentes tramas usando el método sort() de la clase Arrays .
cómo eliminar el primer carácter en excel
El método Arrays.sort() consta de dos variaciones, una en la que no pasamos ningún argumento y ordena la matriz completa, ya sea una matriz de enteros o una matriz de caracteres, pero si se supone que debemos ordenar una parte específica usando este método de la clase Arrays, entonces lo sobrecargamos y pasamos el índice inicial y último a la matriz.
Sintaxis: método ordenar()
Arrays.sort();>
Sintaxis: Método sort() sobrecargado
public static void sort(int[] arr, int from_Index, int to_Index) ;>
Parámetros: Se necesitan tres parámetros, como se puede percibir en la sintaxis, que es la siguiente:
- La matriz a ordenar
- El índice del primer elemento, inclusive, que se va a ordenar (denominado from_index)
- El índice del último elemento, exclusivo, a ordenar (denominado last_index)
Tipo de devolución: ESO
Análisis de complejidad:
Complejidad del tiempo: O(N iniciar sesión N)
Espacio Auxiliar: O(1)
Ahora veamos la implementación de la función sort() en diferentes escenarios de la clase Arrays de la siguiente manera:
Ejemplo 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 +>' '>);> >}> >}> }> |
>
>Producción
The original array is: 5 -2 23 7 87 -42 509 The sorted array is: -42 -2 5 7 23 87 509>
Complejidad del tiempo: O(nlog(n)) como complejidad de arrays.sort()
Espacio Auxiliar: O(1)
Ejemplo 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));> >}> }> |
>
>Producción
Modified arr[] : [6, 7, 9, 13, 21, 45, 101, 102]>
Complejidad del método anterior:
Complejidad del tiempo: O(N iniciar sesión N)
Espacio Auxiliar: O(1)
Ejemplo 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));> >}> }> |
>
>Producción
Modified arr[] : [13, 6, 7, 21, 45, 9, 2, 100]>
Complejidad del método anterior:
Complejidad del tiempo: O(nlog(n)) como complejidad de arrays.sort()
Espacio Auxiliar: O(1)
Ejemplo 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));> >}> }> |
>
>Producción
Modified arr[] : [100, 45, 21, 13, 9, 7, 6, 2]>
Complejidad del método anterior:
Complejidad del tiempo: O(nlog(n)) como complejidad de arrays.sort()
Espacio Auxiliar: O(1)
Ejemplo 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));> >}> }> |
>
>Producción
Modified arr[] : Modified arr[] :[www.techcodeview.com, practice.techcodeview.com, code.techcodeview.com]>
Complejidad del método anterior:
Complejidad del tiempo: O(nlog(n)) como complejidad de arrays.sort()
Espacio Auxiliar: O(1)
Ahora, por último, implementaremos el método sort() al máximo porque aquí declararemos nuestros propios criterios definidos con la ayuda del Interfaz del comparador .
Ejemplo 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]); } }> |
>
>Producción
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc>
Complejidad del método anterior:
Complejidad del tiempo: O(nlog(n)) como complejidad de arrays.sort()
Espacio Auxiliar: O(1)
Recordar: Hay una ligera diferencia entre Arrays.sort() y Colecciones.sort() . Arrays.sort() funciona para matrices que también pueden ser de tipo de datos primitivos. Colecciones .sort() funciona para colecciones de objetos como Lista de arreglo , Lista enlazada , etc.
Usando el método de orden inverso: Este método ordenará la matriz en orden descendente. En la clase Java Collections también se proporciona la orden inverso() método para ordenar la matriz en orden lexicográfico inverso. No analiza ningún parámetro porque es un método estático, por lo que podemos invocarlo directamente usando el nombre de la clase. ordenará las matrices en orden ascendente mediante el método sort() después de eso, el método de orden inversa() nos dará el orden natural y obtendremos la matriz ordenada en orden descendente.
Sintaxis:
Arrays.sort(a, Collections.reverseOrder());>
Ejemplo 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));> >}> }> |
>
>Producción
Array in descending order: [121, 110, 99, 66, 34, 12, 12, 0, -8, -110]>
Complejidad del método anterior:
Complejidad del tiempo: O(nlog(n)) como complejidad de arrays.sort()
Espacio Auxiliar: O(1)