¿Cómo mezclar elementos en LinkedList en Java?

LinkedList es parte del marco de la colección presente en el paquete java.util . Esta clase es una implementación de la estructura de datos LinkedList, que es una estructura de datos lineal donde los elementos no se almacenan en ubicaciones contiguas y cada elemento es un objeto separado con una parte de datos y una parte de dirección. Los elementos se vinculan mediante punteros y direcciones. Cada elemento se conoce como un Node. Dada una LinkedList, la tarea es barajar la LinkedList. Estos son enfoques para resolver el problema.

Enfoque 1 (usando el método definido por el usuario)

• Crear una lista enlazada.
• Almacene sus elementos en una array mediante el método toArray() . 
• Mezcla los elementos de la array.
• Use ListIterator en LinkedList y recorra LinkedList con el método next() y almacene los datos mezclados de Array en List simultáneamente con el método set() .

Ejemplo

import java.util.*;
public class GFG {
  
    public static void main(String args[])
    {
  
        // creating an instance of LinkedList
        LinkedList<Object> list = new LinkedList<>();
  
        // adding data to the LinkedList
        list.add(45);
        list.add("GFG");
        list.add(2.56f);
        list.add(965.321);
        list.add('A');
        list.add(true);
  
        System.out.println("The list before shuffle : "
                           + list.toString());
        System.out.println();
  
        // creating an Array and storing all data of the
        // list to the array
        Object[] array = list.toArray();
  
        // here we are shuffling more than once
        // shuffle 1
        arrayShuffle(array);
        listDataAdder(array, list);
        System.out.println("The list after shuffle 1 : "
                           + list.toString());
        System.out.println();
  
        // shuffle 2
        arrayShuffle(array);
        listDataAdder(array, list);
        System.out.println("The list after shuffle 2 : "
                           + list.toString());
        System.out.println();
  
        // shuffle 3
        arrayShuffle(array);
        listDataAdder(array, list);
        System.out.println("The list after shuffle 3 : "
                           + list.toString());
    }
  
    // Creating a data to add shuffled data of the array to
    // the list
    static void listDataAdder(Object[] arr,
                              LinkedList<Object> list)
    {
        // creating a ListIterator on the LinkedList
        ListIterator<Object> it = list.listIterator();
  
        // Traversing the LinkedList and setting all
        // shuffled data of the array to the list
        for (Object e : arr) {
            it.next();
            it.set(e);
        }
    }
  
    // creating a method to shuffle the array
    static void arrayShuffle(Object[] arr)
    {
        Random rand = new Random();
        for (int i = 0; i < arr.length - 1; i++) {
            
            // select index randomly
            int index = rand.nextInt(i + 1);
            
            // swapping between i th term and the index th
            // term
            Object g = arr[index];
            arr[index] = arr[i];
            arr[i] = g;
        }
    }
}

The list before shuffle : [45, GFG, 2.56, 965.321, A, true]

The list after shuffle 1 : [965.321, 2.56, GFG, 45, A, true]

The list after shuffle 2 : [965.321, 45, A, 2.56, GFG, true]

The list after shuffle 3 : [965.321, 45, GFG, 2.56, A, true]

Enfoque 2 (usando Collections.shuffle (list) )

• Crear una lista enlazada.
• Mezcla los elementos de la lista usando el método shuffle() de la clase Collections .

Declaración

public static void shuffle(List<?> list)

Sintaxis

Collections.shuffle(list);

Excepción: este método lanza la excepción UnsupportedOperationException si la lista dada o su iterador de lista no admite la operación de configuración.

Ejemplo:

import java.util.Collections;
import java.util.LinkedList;
  
public class GFG {
    public static void main(String args[])
    {
        // Creating a LinkedList
        LinkedList<Object> list = new LinkedList<>();
        list.add(45);
        list.add("GFG");
        list.add(2.56f);
        list.add(965.321);
        list.add('A');
        list.add(true);
  
        System.out.println(
            "The LinkedList before shuffle : "
            + list.toString());
        System.out.println();
  
        // here we are shuffling more than once
        // shuffle 1
        Collections.shuffle(list);
        System.out.println(
            "The LinkedList after shuffle 1 : "
            + list.toString());
        System.out.println();
  
        // shuffle 2
        Collections.shuffle(list);
        System.out.println(
            "The LinkedList after shuffle 2 : "
            + list.toString());
        System.out.println();
  
        // shuffle 3
        Collections.shuffle(list);
        System.out.println(
            "The LinkedList after shuffle 3 : "
            + list.toString());
    }
}

The LinkedList before shuffle : [45, GFG, 2.56, 965.321, A, true]

The LinkedList after shuffle 1 : [965.321, 2.56, true, 45, GFG, A]

The LinkedList after shuffle 2 : [2.56, A, true, 45, GFG, 965.321]

The LinkedList after shuffle 3 : [GFG, A, 965.321, 45, true, 2.56]