java - operaciones - listas simples estructura de datos

¿Almacena más de 1 elemento de datos en un solo índice en una lista enlazada?

Question

Estoy tratando de almacenar más de 1 elemento de datos en un solo índice en mi lista de enlaces. Todos los ejemplos en mi libro de texto parecen ilustrar agregar solo 1 pieza de datos por índice. ¿Asumo que es posible agregar más?

Por ejemplo, al utilizar la API de colecciones para almacenar un número entero, haré lo siguiente:

LinkedList <Integer>linky = new LinkedList<Integer>();
int num1 = 2, num2 = 22, num3 = 25, num4 = 1337;
linky.add(num1);

¿Cómo podría agregar num2, num3 y num4 al mismo primer índice en la lista? Gracias chicos.

Answer 1

Usa una estructura

Por ejemplo:

private struct Node
{
    int Num1;
    int Num2;
    int Num3;
}

...

LinkedList<Node> list = new LnkedList<Node>();

Node n = new Node();
n.Num1 = 10;
n.Num2 = 100;
n.Num3 = 1000;
list.Add(n);

Nota; Supongo que esto está en C #; corrígeme si me equivoco y corregiré el código;)

Si aún no ha revisado OOP en su libro, le recomiendo que lo intente; te ayudará a resolver problemas como este.

Answer 2

¿Por qué no algo así?

LinkedList<LinkedList<Integer>> linky = new LinkedList<LinkedList<Integer>>();
//...
linky.add(new LinkedList<Integer>().add( //...

Answer 3

Aquí hay un ejemplo de código completo que muestra el uso de agregar una estructura a una lista vinculada:

import java.util.LinkedList;
class Node {
    int num1;
    int num2;
    int num3;
    int num4;
    public Node(int a, int b, int c, int d) {
        num1 = a; num2 = b; num3 = c; num4 = d;
    }
}
public class dummy {
    public static void main(String[] args) {
        LinkedList <Node>linky = new LinkedList<Node>();
        x myNode = new Node(2, 22, 25, 1337);
        linky.add(myNode);
    }
}

Answer 4

Parece haber una pequeña confusión sobre cómo funcionan las listas enlazadas. Esencialmente, una lista vinculada está compuesta de nodos, cada uno de los cuales contiene un dato (un objeto, que puede contener varias variables miembro, para ser precisos), y un enlace al siguiente nodo en la lista (o un puntero nulo si hay no es ese próximo nodo). También puede tener una lista de enlaces dobles, donde cada nodo también tiene un puntero al nodo anterior en la lista, para acelerar ciertos tipos de patrones de acceso.

Para agregar varias "piezas de datos" a un solo nodo, suena como agregar varios enlaces fuera de un nodo, lo que convierte su lista vinculada en un árbol N-ario.

Para agregar varias piezas de datos al final de la lista, de la manera más comúnmente asociada con una lista enlazada, solo haga lo siguiente:

LinkedList <Integer>linky = new LinkedList<Integer>();
int num1 = 2, num2 = 22, num3 = 25, num4 = 1337;
linky.add(num1);
linky.add(num2);
linky.add(num3);
linky.add(num4);

Alternativamente, si desea que cada nodo de la lista vinculada tenga varios datos

Estos datos se deben empaquetar en un objeto (definiendo una class que los tenga a todos como variables miembro). Por ejemplo:

class GroupOfFourInts
{
   int myInt1;
   int myInt2;
   int myInt3;
   int myInt4;

   public GroupOfFourInts(int a, int b, int c, int d)
   {
     myInt1 = a; myInt2 = b; myInt3 = c; myInt4 = d;
   }
}

class someOtherClass
{

  public static void main(String[] args)
  {
    LinkedList<GroupOfFourInts> linky = new LinkedList<GroupOfFourInts>();
    GroupOfFourInts group1 = new GroupOfFourInts(1,2,3,4);
    GroupOfFourInts group2 = new GroupOfFourInts(1337,7331,2345,6789);
    linky.add(group1);
    linky.add(group2);
  }
}

Ahora, linky tendrá 2 nodos, cada uno de los cuales contendrá 4 int s, myInt1 , myInt2 , myInt3 y myInt4 .

Nota

Ninguno de los anteriores es específico de las listas vinculadas. Este patrón debe usarse siempre que desee almacenar una gran cantidad de datos como una unidad. Usted crea una clase que tiene variables miembro para cada elemento de datos que desea almacenar juntos, luego crea cualquier tipo de colecciones Java (ArrayList, LinkedList, TreeList, ...) de ese tipo.

Asegúrese de que desea utilizar una lista vinculada (ya que no hay penalización en términos de dificultad de programación al elegir una ArrayList o una TreeList). Esto dependerá de su patrón de acceso a datos. Las listas vinculadas proporcionan O (1) adición y eliminación, pero O (n) búsqueda, mientras que ArrayLists proporciona O (1) búsqueda, pero O (n) arbitrario agrega y elimina. TreeLists proporciona inserción, eliminación y búsqueda O (log n). Los intercambios entre estos dependen de la cantidad de datos que tenga y cómo va a modificar y acceder a la estructura de datos.

Por supuesto, nada de esto importa si solo tienes, digamos, <100 elementos en tu lista ;-)

¡Espero que esto ayude!

Answer 5

Realmente no entiendo lo que estás tratando de lograr, entonces sugiero una solución para otra lectura del problema (en java).

LinkedList <Integer>linky = new LinkedList<Integer>();
linky.add(num1);

// Lots of code possibly adding elements somewhere else in the list

if (linky.size() > 0) { // Always good to be sure; especially if this is in another methode
 int first = linky.get(0);
 linky.set(0, first + num2);// Value of linky.get(0) is num1 + num2 
}


// The same again
// Lots of code possibly adding elements somewhere else in the list

if (linky.size() > 0) { // Always good to be sure; especially if this is in another methode
 int first = linky.get(0);
 linky.set(0, first + num3); // Value of linky.get(0) is num1 + num2 + num3
}

Personalmente, me gusta más la solución de Nelson si la cantidad de números para agregar es constante (num1 .. num4), y si no es constante preferiría la solución de Gregor (que usa una lista en lugar de un nodo). Si elige el método Node en java, le sugiero que:

// added static, Class to class
private static class Node
{
    //You might want to make these private, and make setters and getters
    public int Num1;
    public int Num2;
    puclic int Num3;
}

// Prefer interfaces if possible
List<Node> list = new LinkedList<Node>();

Node n = new Node();
n.Num1 = 10;
n.Num2 = 100;
n.Num3 = 1000;
list.add(n); // Add -> add

Hay muchos detalles, pero creo que, si es posible, se prefiere una clase estática en lugar de una clase privada no estática (y normalmente debería ser posible).

Answer 6

Como Nelson dijo que necesita otro objeto, en Java, aunque necesita usar una clase. Si necesita que la clase ''Node'' se use fuera de la clase en la que está trabajando, entonces debe convertirla en una clase pública y moverla a su propio archivo.

private Class Node
{
    //You might want to make these private, and make setters and getters
    public int Num1;
    public int Num2;
    puclic int Num3;
}

LinkedList<Node> list = new LinkedList<Node>();

Node n = new Node();
n.Num1 = 10;
n.Num2 = 100;
n.Num3 = 1000;
list.Add(n);

Disculpas a Nelson por robar su código;)