SLinkedList und Knoten in Java
Mit zu beginnen, ja, das ist für eine Zuordnung in die Klasse, aber mein Mangel an Verständnis, wie es funktioniert, ist höher, als ich es will.
Erhielten wir 3 Klassen, Sie sind die folgenden:
SLinkedList.java
package chapter3.linkedList;
public class SLinkedList<V> {
//instance variables. Add the tail reference.
protected Node<V> head, tail;
protected long size;
//methods, empty list constructor first
public SLinkedList () {
head = null;
tail = null;
size = 0;
} //end constructor of a SLinkedList
//method to add nodes to the list. Storage space for the node
//is already allocated in the calling method
public void addFirst (Node<V> node) {
//set the tail only if this is the very first node
if (tail == null)
tail = node;
node.setNext (head); //make next of the new node refer to the head
head = node; //give head a new value
//change our size
size++;
} //end method addFirst
//addAfter - add new node after current node, checking to see if we are at the tail
public void addAfter (Node<V>currentNode, Node<V>newNode) {
if (currentNode == tail)
tail = newNode;
newNode.setNext (currentNode.getNext ());
currentNode.setNext (newNode);
//change our size
size++;
} //end method addAfter
//addLast - add new node after the tail node. Adapted from Code Fragment 3.15, p. 118.
//Mike Qualls
public void addLast (Node<V> node) {
node.setNext (null);
tail.setNext (node);
tail = node;
size++;
} //end method addLast
//methods to remove nodes from the list. (Unfortunately, with a single linked list
//there is no way to remove last. Need a previous reference to do that. (See
//Double Linked Lists and the code below.)
public Node<V> removeFirst () {
if (head == null)
System.err.println("Error: Attempt to remove from an empty list");
//save the one to return
Node<V> temp = head;
//do reference manipulation
head = head.getNext ();
temp.setNext(null);
size--;
return temp;
} //end method removeFirst
//remove the node at the end of the list. tail refers to this node, but
//since the list is single linked, there is no way to refer to the node
//before the tail node. Need to traverse the list.
public Node<V> removeLast () {
////declare local variables/objects
Node<V> nodeBefore;
Node<V> nodeToRemove;
//make sure we have something to remove
if (size == 0)
System.err.println("Error: Attempt to remove fron an empty list");
//traverse through the list, getting a reference to the node before
//the trailer. Since there is no previous reference.
nodeBefore = getFirst ();
//potential error ?? See an analysis and drawing that indicates the number of iterations
//9/21/10. size - 2 to account for the head and tail nodes. We want to refer to the one before the
//tail.
for (int count = 0; count < size - 2; count++)
nodeBefore = nodeBefore.getNext ();
//save the last node
nodeToRemove = tail;
//now, do the pointer manipulation
nodeBefore.setNext (null);
tail = nodeBefore;
size--;
return nodeToRemove;
} //end method removeLast
//method remove. Remove a known node from the list. No need to search or return a value. This method
//makes use of a 'before' reference in order to allow list manipulation.
public void remove (Node<V> nodeToRemove) {
//declare local variables/references
Node<V> nodeBefore, currentNode;
//make sure we have something to remove
if (size == 0)
System.err.println("Error: Attempt to remove fron an empty list");
//starting at the beginning check for removal
currentNode = getFirst ();
if (currentNode == nodeToRemove)
removeFirst ();
currentNode = getLast ();
if (currentNode == nodeToRemove)
removeLast ();
//we've already check two nodes, check the rest
if (size - 2 > 0) {
nodeBefore = getFirst ();
currentNode = getFirst ().getNext ();
for (int count = 0; count < size - 2; count++) {
if (currentNode == nodeToRemove) {
//remove current node
nodeBefore.setNext (currentNode.getNext ());
size--;
break;
} //end if node found
//change references
nodeBefore = currentNode;
currentNode = currentNode.getNext ();
} //end loop to process elements
} //end if size - 2 > 0
} //end method remove
//the gets to return the head and/or tail nodes and size of the list
public Node<V> getFirst () { return head; }
public Node<V> getLast () { return tail; }
public long getSize () { return size; }
} //end class SLinkedList
Node.java
Paket chapter3.linkedList;
public class Node<V> {
//instance variables
private V element;
private Node<V> next;
//methods, constructor first
public Node () {
this (null, null); //call the constructor with two args
} //end no argument constructor
public Node (V element, Node<V> next) {
this.element = element;
this.next = next;
} //end constructor with arguments
//set/get methods
public V getElement () { return element; }
public Node<V> getNext () { return next; }
public void setElement (V element) { this.element = element; }
public void setNext (Node<V> next) { this.next = next; }
} //end class Node
und GameEntry.java
package Project_1;
public class GameEntry
{
protected String name; //name of the person earning this score
protected int score; //the score value
/** Constructor to create a game entry */
public GameEntry(String name, int score)
{
this.name = name;
this.score = score;
}
/** Retrieves the name field */
public String getName()
{
return name;
}
/** Retrieves the score field */
public int getScore()
{
return score;
}
/** Returns a string representation of this entry */
public String toString()
{
return "(" + name + ", " + score + ")";
}
}
Ich habe in den letzten 3 Stunden Zuhören zu seinem Vortrag, Lesung durch den text (Datenstrukturen und Algorithmen 5. Auflage), und suchen durch internet-Foren und youtube-videos, aber ich kann nicht scheinen zu begreifen, zu verstehen, wie er den Knoten/slinkedlist Klasse.
Gegenstand der Abtretung ist "Schreiben Sie eine Klasse, die behauptet, die top 10 erreicht souverän oder ein Spiel-Anwendung, die Implementierung der add-und remove-Methoden, sondern mithilfe einer einfach verkettete Liste statt einem array.
Ich nicht wollen, dass jemand das für mich tun, ich will aber wissen, wie man die verlinkte Liste. Ich weiß diese sind NICHT so schwer, aber tun Sie mit diesem code, den er gegeben hat, schmerzhaft schwer, jede Hilfe wäre wirklich zu schätzen.
Vielen Dank im Voraus.
Edit:
Meine main-Funktion: ScoresTest.java
package Project_1;
public class ScoresTest {
/**
* @param args
*/
public static void main(String[] args)
{
GameEntry entry;
Scores highScores = new Scores();
entry = new GameEntry("Anna", 600);
highScores.add(entry);
entry = new GameEntry("Paul", 720);
highScores.add(entry);
System.out.println("The Original High Scores");
System.out.println(highScores);
entry = new GameEntry("Jill", 1150);
highScores.add(entry);
System.out.println("Scores after adding Jill");
System.out.println(highScores);
}
}
Dies ist zum größten Teil genau so sollte es am Ende der Suche, aber es ist alles, dass macht diese Arbeit, werfe mich Weg...naja...alles was den Umgang mit den 3 Klassen, die oben erwähnten, konnte ich dies tun, wenn Sie waren nicht ein Faktor, ohne zu viel von einem Problem, Sie sind das, was verursacht meine leere.
Es ist alles scheinbar in den Partituren Fahrer sind wir zu erstellen haben wir zu call-Knoten, gameentry, und slinkedlist, damit es funktioniert, und ich bin nur nicht sicher, wie dies zu tun. Ich bin sicher, es kann nicht so schwer sein, aber aus irgendeinem Grund kann ich einfach nicht verstehen.
Sie verstehen das Konzept einer main-Methode, und die Generika-oder ist dies Ihre erste java-Klasse? Benutzt du eine IDE?
Fortgeschrittene Java, aber habe ich nicht getan, java für einige Zeit. Wir sind mit eclipse und ich verstehe das Konzept der main-Methode, ich werde das hinzufügen meiner main-Methode, wie Sie dies Lesen.
OK, ich sehe Ihr nun Bearbeiten, sind Sie gehen zu müssen, um die GameEntry auf die LL-das, was Sie wollen, um Ihre LL zu speichern.
InformationsquelleAutor Soully | 2011-09-13
Du musst angemeldet sein, um einen Kommentar abzugeben.
Hier ist ein Skelett, ohne dabei viel für Sie ist dies zumindest spricht Sie durch, was Sie bisher in den Kommentaren oben:
Sobald Sie diese in eclipse, auto-complete wird Sie ziemlich weit. Die Instanziierung der LinkedList-Klasse mit generics könnte seltsam sein, wenn Sie habe Sie nie gesehen. Fokus, auf SLinkedList obwohl es hat eine Menge von utility für das, was Sie tun wollen, sorgen sich nicht darum, Knoten zu viel im Voraus.
Viel Glück, wenn Sie gehen, um genau das verstärkt zu tun, sollten Sie einen Blick auf ein java-generics-tutorial.
Hab es, danke so sehr für das, macht durchaus Sinn und alles Super geklappt!
InformationsquelleAutor Mike K.