Speicher von mehr als 1 Datenelement in einem einzigen Index in einer verketteten Liste?

Question

Ich versuche, in meiner verketteten Liste in einem einzigen Index mehr als 1 Datenelement zu speichern. Alle Beispiele in meinem Lehrbuch scheinen nur 1 Stück Daten pro Index zu illustrieren hinzufügen. Ich gehe davon aus es möglich ist, mehr hinzufügen?

Zum Beispiel der Sammlungen API eine ganze Zahl speichern ich folgende tun würde:

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

Wie würde ich mich über das Hinzufügen von num2, num3 und num4 auf den gleichen ersten Index in der Liste? Danke Leute.

Answer 1

Es scheint ein wenig Verwirrung darüber zu sein, wie verkettete Listen arbeiten. Im Wesentlichen wird eine verknüpfte Liste von Knoten bestehen, von denen jede ein Datum enthält (ein Objekt, das sich mehrere Elementvariablen enthalten kann, um genau zu sein), und einen Link zu dem nächsten Knoten in der Liste (oder einen Null-Zeiger, wenn ist kein solcher nächsten Knoten). Sie können auch eine doppelt verknüpfte Liste, wobei jeder Knoten auch einen Zeiger auf den vorherigen Knoten in der Liste hat, zu beschleunigen bestimmte Arten von Zugriffsmustern.

Um mehr „Datenstücke“ zu einem einzelnen Knoten klingt wie das Hinzufügen mehr Links weg von einem Knoten, der dann auch verknüpften Liste in einen N-ary Baum .

hinzufügen

Um mehrere Stücke von Daten an das Ende der Liste, in der Art und Weise am häufigsten im Zusammenhang mit einer verknüpften Liste hinzufügen, gerade tun:

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);

Alternativ, wenn Sie wollen, dass jeder Knoten der verknüpften Liste mehrere Stücke von Daten haben

sollten diese Daten verpackt werden bis in eine Objekt (durch eine class definieren, die sie alle als Elementvariablen aufweist). Zum Beispiel:

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);
  }
}

Nun wird linky 2 Knoten haben, von denen jeder vier ints enthalten, myInt1 myInt2 myInt3 und myInt4 .

Hinweis

Keine der oben Genannten ist spezifisch für verkettete Listen. Dieses Muster soll verwendet werden, wenn Sie eine Reihe von Daten zusammen als eine Einheit gespeichert werden sollen. Sie erstellen eine Klasse, die zusammen gelagert werden muss, dann erstellen Sie eine beliebige Java Collections Art (Arraylist, LinkedList, TreeList, ...) dieses Typs Elementvariablen für jedes Stück von Daten, die Sie wollen.

Seien Sie sicher, dass Sie eine verkettete Liste verwenden möchten (wie es in der Programmierung Schwierigkeiten keine Strafe ist bei der Auswahl eines Arraylist oder TreeList). Dies wird auf dem Datenzugriffsmuster abhängen. Verkettete Listen liefern O (1) Hinzufügen und Löschen, aber O (n) Nachschlagen, während Arraylisten O (1) bereitzustellen Lookup, aber O (n) beliebige hinzuzufügen und löschen. TreeLists bereitzustellen O (log n) Einfügen, Löschen und Suchen. Die Kompromisse zwischen diesen abhängig von der Menge der Daten, die Sie haben und wie du gehst, um die Datenstruktur zu ändern und den Zugriff.

Natürlich nichts davon zählt, wenn Sie nur, sagen wir, <100 Elemente in der Liste; -)

Hope, das hilft!

Answer 2

eine Struktur verwenden.

Zum Beispiel:

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);

Hinweis; Ich nehme an, dies in C # ist; korrigieren Sie mich, wenn ich falsch liege, und ich werde den Code korrigieren;)

Wenn Sie nicht über OOP noch in Ihrem Buch gegangen sind - dann würde ich empfehlen, es zu versuchen; es wird Ihnen helfen, Probleme wie diese zu lösen.

Answer 3

Warum nicht etwas wie folgt aus:

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

Answer 4

Wie Nelson sagte, Sie ein anderes Objekt benötigt, in Java wenn Sie eine Klasse verwenden müssen. Wenn Sie den ‚Knoten‘ Klasse müssen außerhalb der Klasse verwendet werden Sie arbeiten in, dann müssen Sie es eine öffentliche Klasse zu machen, und es zu seiner eigenen Datei zu verschieben.

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);

Apologies zu Nelson für seinen Code zu stehlen;)

Answer 5

Hier ist ein vollständiges Codebeispiel, das die Verwendung von Hinzufügen einer Struktur zu einer verknüpften Liste zeigt:

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 6

ich nicht wirklich verstehen, was Sie erreichen wollen, so schlage ich vor, eine Lösung für eine andere Lektüre des Problems (in 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
}

Ich persönlich passieren Nelson-Lösung am besten, wenn die Menge von Zahlen gerne hinzufügen, konstant ist (num1 .. num4), und wenn es nicht konstant ist, würde ich Gregors Lösung bevorzugen (die eine Liste anstelle eines Knotens verwendet). Wenn Sie die Knoten-Methode in Java gehen Ich schlage vor:

// 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

Eine Menge an Erbsenzählerei, aber ich denke, eine statische Klasse anstelle eines keine statischen private Klasse, wenn möglich, bevorzugt (und es sollte in der Regel möglich).