En Java, LinkedList es parte del marco de colección proporcionado en el paquete java.util . LinkedList es una estructura de datos lineal donde todos los elementos están ordenados en ubicaciones de memoria contiguas. La ventaja de LinkedList es que es dinámico y fácil de insertar y eliminar cualquier elemento. No podemos acceder a ningún Node de LinkedList directamente, necesitamos comenzar con el Node Head y atravesar una LinkedList.
Comparable proporciona una única secuencia de clasificación. Si usamos Comparable, afectará a la clase original. Comparable Interface proporciona el método compareTo() para ordenar elementos. En java, el paquete java.lang proporciona comparables. Podemos ordenar la LinkedList invocando el método Collections.sort(List).
LinkedList se puede ordenar en el siguiente orden usando Comparable:
- orden ascendente
- Orden descendiente
- Uso de Collections.reverseOrder()
- Anular el método CompareTo()
Tipo 1: orden ascendente
Para ordenar una LinkedList en orden Ascendente usando Comparable, necesitamos implementar la interfaz Comparable en nuestra clase y anular el método CompareTo() para ordenar una LinkedList con respecto a elementos específicos. Después de eso, necesitamos usar el método Collection.sort() para ordenar una LinkedList.
Sintaxis: Collections.sort(Listobject)
Ejemplo:
Java
// Java Program to Sort LinkedList using Comparable
// in ascending order
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
// User defined class implements Comparable
class Student implements Comparable<Student> {
String Name;
int Id;
int Rank;
Student(String name, int id, int rank)
{
this.Name = name;
this.Id = id;
this.Rank = rank;
}
// Override the compareTo() method
@Override public int compareTo(Student s)
{
if (Rank > s.Rank) {
return 1;
}
else if (Rank == s.Rank) {
return 0;
}
else {
return -1;
}
}
}
public class Main {
// Main driver method
public static void main(String[] args)
{
// Create one LinkedList for Student object
LinkedList<Student> List
= new LinkedList<Student>();
List.add(new Student("Meet", 32, 2));
List.add(new Student("Jhon", 11, 5));
List.add(new Student("Sham", 92, 1));
List.add(new Student("William", 86, 3));
List.add(new Student("Harry", 35, 4));
// Print the Unsorted LinkedList
System.out.println("UnSorted List");
for (Student s : List) {
System.out.println(s.Rank + " " + s.Name + " "
+ s.Id);
}
System.out.println();
// sort in ascending order
Collections.sort(List);
// Print the sorted LinkedList
System.out.println("Sorted List");
for (Student s : List) {
// Print the sorted LinkedList
System.out.println(s.Rank + " " + s.Name + " "
+ s.Id);
}
}
}
UnSorted List 2 Meet 32 5 Jhon 11 1 Sham 92 3 William 86 4 Harry 35 Sorted List 1 Sham 92 2 Meet 32 3 William 86 4 Harry 35 5 Jhon 11
Complejidad de tiempo: O(n log n)
Tipo 2: orden descendente
Para ordenar una Lista Vinculada en orden Descendente tenemos dos Enfoques.
A. Usando Collections.reverseOrder()
En este enfoque, primero tenemos que ordenar una LinkedList en orden Ascendente y luego usar Collections.reverseOrder() podemos invertir el orden de la LinkedList ordenada.
Sintaxis: Collections.sort(Listobject,Collections.reverseOrder())
Ejemplo:
Java
// Sort LinkedList using Comparable in Java
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
// User defined class implements Comparable
class Student implements Comparable<Student> {
String Name;
int Id;
int Rank;
Student(String name, int id, int rank)
{
this.Name = name;
this.Id = id;
this.Rank = rank;
}
// Override the compareTo() method
@Override public int compareTo(Student s)
{
if (Rank > s.Rank) {
return 1;
}
else if (Rank == s.Rank) {
return 0;
}
else {
return -1;
}
}
}
public class Main {
// Main driver method
public static void main(String[] args)
{
// Create one LinkedList for Student object
LinkedList<Student> List
= new LinkedList<Student>();
List.add(new Student("Meet", 32, 2));
List.add(new Student("Jhon", 11, 5));
List.add(new Student("Sham", 92, 1));
List.add(new Student("William", 86, 3));
List.add(new Student("Harry", 35, 4));
// Print the Unsorted LinkedList
System.out.println("UnSorted List");
for (Student s : List) {
System.out.println(s.Rank + " " + s.Name + " "
+ s.Id);
}
System.out.println();
// sort in descending order
Collections.sort(List, Collections.reverseOrder());
// Print the sorted LinkedList
System.out.println("Sorted List");
for (Student s : List) {
// Print the sorted LinkedList
System.out.println(s.Rank + " " + s.Name + " "
+ s.Id);
}
}
}
UnSorted List 2 Meet 32 5 Jhon 11 1 Sham 92 3 William 86 4 Harry 35 Sorted List 5 Jhon 11 4 Harry 35 3 William 86 2 Meet 32 1 Sham 92
Complejidad de tiempo: O(n log n)
B. Anular el método CompareTo()
En este enfoque, tenemos que anular el método compareTo() de tal manera que devuelva una LinkedList en orden descendente.
Ejemplo:
Java
// Sort LinkedList using Comparable in Java
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
// User defined class implements Comparable
class Student implements Comparable<Student> {
String Name;
int Id;
int Rank;
Student(String name, int id, int rank)
{
this.Name = name;
this.Id = id;
this.Rank = rank;
}
// Override the compareTo() method
@Override public int compareTo(Student s)
{
// Changed the Comparison logic
if (Rank < s.Rank) {
return 1;
}
else if (Rank == s.Rank) {
return 0;
}
else {
return -1;
}
}
}
public class Main {
// Main driver method
public static void main(String[] args)
{
// Create ine LinkedList for Student object
LinkedList<Student> List
= new LinkedList<Student>();
List.add(new Student("Meet", 32, 2));
List.add(new Student("Jhon", 11, 5));
List.add(new Student("Sham", 92, 1));
List.add(new Student("William", 86, 3));
List.add(new Student("Harry", 35, 4));
// Print the Unsorted LinkedList
System.out.println("UnSorted List");
for (Student s : List) {
System.out.println(s.Rank + " " + s.Name + " "
+ s.Id);
}
System.out.println();
// sort in ascending order
Collections.sort(List);
// Print the sorted LinkedList
System.out.println("Sorted List");
for (Student s : List) {
// Print the sorted LinkedList
System.out.println(s.Rank + " " + s.Name + " "
+ s.Id);
}
}
}
UnSorted List 2 Meet 32 5 Jhon 11 1 Sham 92 3 William 86 4 Harry 35 Sorted List 5 Jhon 11 4 Harry 35 3 William 86 2 Meet 32 1 Sham 92
Complejidad de tiempo: O(n log n)
Publicación traducida automáticamente
Artículo escrito por meetsuvariya y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA