Listas enlazadas (LinkedLists) en Java

/* Se muestra ejemplo de lista enlazada: paso de array a lista, inserción de elementos, lectura inversa y ordenamiento. */

package listas;

import java.util.*;

/*
 * @author ARF, RLR
 */
public class Listas {

    public static void main(String[] args) 
    {
        Double[] x = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};

        //PASO A LISTA
        List<Double> unaLista = new LinkedList<>(Arrays.asList(x));

        //ORDEN INVERSO E INSERCION
        ordenInverso(unaLista);
        insertar(unaLista, -7.0);
        System.out.println(unaLista);
        insertar(unaLista, 4.5);
        System.out.println(unaLista);
        insertar(unaLista, 22.0);
        System.out.println(unaLista);

        //INSERCION LOCALIZADA 
        insertar1(unaLista, 20.0,12);
        System.out.println(unaLista);
        insertar1(unaLista, 20.0,15);
        System.out.println(unaLista);
        insertar1(unaLista, 20.0,1);
        System.out.println(unaLista);
        insertar1(unaLista, 20.0,-3);
        System.out.println(unaLista);

        //REORDENAMIENTO DE ARRAY
        x[3]=20.0;
        System.out.println(ordenar1(x));

        //REORDENAMIENTO DE LISTA
        System.out.println(ordenar1(unaLista));

        //OBSERVAR LA SOBRECARGA DEL MÉTODO ordenar1()

    }

    public static void ordenInverso(List lista) 
    {
        // COLOCAR ITERATOR AL FINAL
        ListIterator li = lista.listIterator(lista.size());

        while(li.hasPrevious()) 
        {
            System.out.print("  " + li.previous());
        }
        System.out.println();
    }

    // Método sobre tipos T que implementan la Interfaz Comparable<T> 
    // Comparable<T> implementa un único método --> int compareTo(T obj)
    public static <T extends Comparable<T>>
                   void insertar(List<T> lista, T elto) 
    {
        ListIterator<T> li = lista.listIterator();
        while(li.hasNext()) 
        {
            T actual = li.next();
            if (elto.compareTo(actual)<0) 
            {
                li.previous();
                li.add(elto);
                return;
            }
        }
        lista.add(elto);
    }

    public static <T extends Comparable<T>> 
           void insertar1(List<T> lista, T elto, int index) 
    {

        if(index>lista.size()) 
        {
            index=lista.size();
            ListIterator<T> li = lista.listIterator(index);
            li.add(elto);
            return;
        }                                    

        if(index<1) index=1;
        ListIterator<T> li = lista.listIterator(index);
        li.previous();
        li.add(elto);                   
    }

    public static <T extends Comparable<T>> List<T> ordenar1(T[] x) 
    {
        List<T> lista = new LinkedList<>(Arrays.asList(x));
        Collections.sort(lista);
        return lista;
    }

    public static <T extends Comparable<T>> 
                  List<T> ordenar1(List<T> lista) 
    {
        List<T> lista1 = new LinkedList<>(lista);
        Collections.sort(lista1);
        return lista1;
    }

}
Esta entrada fue publicada en Ciencia y programación. Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s