-
Ihre Implementierung lässt keine leere Liste zu.
- Es ist ein bisschen seltsam, nur den Konstruktor zu haben, der einen Knotenwert annimmt.
Sie sollten die
List
Schnittstelle wahrscheinlich implementieren .Sie sollten sich mit Generika befassen, anstatt Ihre Liste fest zu codieren, um nur
int
s zu erhalten.Es sieht so aus
insert()
, als würden Sie versuchen, eine geordnete verknüpfte Liste zu erstellen . Tut esappend()
aber nicht. (Wenn Sie wirklich eine geordnete verknüpfte Liste definieren möchten, können Sie immer noch Generics verwenden, aber Sie müssen Typen verwenden, die untergeordnet sindComparable
).In
insert()
unddelete()
du hast einigeif
Bedingungen, gefolgt von einerwhile
Schleife. Ich vermute, dass sie in einer einzigenwhile
Schleife zusammengefügt werden können. Ich war faul und habe es noch nicht versucht, es könnte also nicht wahr sein.
Java-Code für verknüpfte Liste
Ich habe die Implementierung einer verketteten Liste von Grund auf geübt. Kann jemand helfen, meinen Code zu überprüfen?
class Node {
Node next;
int num;
public Node(int val) {
num = val;
next = null;
}
}
public class LinkedList {
Node head;
public LinkedList(int val) {
head = new Node(val);
}
public void append(int val) {
Node tmpNode = head;
while (tmpNode.next != null) {
tmpNode = tmpNode.next;
}
tmpNode.next = new Node(val);
}
public void insert(int val) {
Node currentNode = head;
Node nextNode = head.next;
if (currentNode.num > val) {
Node tmpNode = head;
head = new Node(val);
head.next = tmpNode;
return;
}
if (nextNode != null && nextNode.num > val) {
currentNode.next = new Node(val);
currentNode.next.next = nextNode;
return;
}
while (nextNode != null && nextNode.num < val) {
currentNode = nextNode;
nextNode = nextNode.next;
}
currentNode.next = new Node(val);
currentNode.next.next = nextNode;
}
public void delete(int val) {
Node prevNode = null;
Node currNode = head;
if (head.num == val) {
head = head.next;
return;
}
while (currNode != null && currNode.num != val) {
prevNode = currNode;
currNode = currNode.next;
}
if (currNode == null) {
System.out.println("A node with that value does not exist.");
}
else {
prevNode.next = currNode.next;
}
}
public void print() {
Node tmpNode = head;
while (tmpNode != null) {
System.out.print(tmpNode.num + " -> ");
tmpNode = tmpNode.next;
}
System.out.print("null");
}
public static void main(String[] args) {
LinkedList myList = new LinkedList(5);
myList.append(7);
myList.append(16);
myList.insert(9);
myList.insert(4);
myList.insert(6);
myList.insert(17);
myList.delete(16);
myList.delete(5);
myList.delete(4);
myList.delete(17);
myList.delete(34);
myList.print();
}
}
Ich habe gerade erkannt, dass meine Append-Funktion am Anfang auch nicht überprüft, ob head null ist. Meine aktuelle Funktion würde eine NPE auslösen, wenn sie null wäre.
Adam Johns vor 7 Jahren
1
3 Antworten auf die Frage
6
toto2
4
Anirban Nag 'tintinmj'
4
guitar_freak
Genau wie gesagt:
-
Mischen
insert()
mitappend()
? Macht das Sinn? Wähle ein - Sie akzeptieren keine leere Liste.
Hier ist ein turbo-schnelles Beispiel mit dem append()
Akzeptieren einer leeren Liste:
class Node {
Node next;
int num;
public Node(int val) {
num = val;
next = null;
}
}
class LinkedList {
private Node head = null;
public void append(int val) {
Node lastNode = getLastNode();
if (lastNode == null) {
head = new Node(val);
} else {
lastNode.next = new Node(val);
}
}
public void delete(int val) {
if(head == null){
return;
}
Node prevNode = null;
Node currNode = head;
while (currNode != null && currNode.num != val) {
prevNode = currNode;
currNode = currNode.next;
}
if(prevNode == null){
head = head.next;
return;
}
if (currNode == null) {
System.out.println("A node with that value does not exist.");
return;
}
prevNode.next = currNode.next;
}
public void print() {
System.out.println("");
if(head == null){
System.out.print("EMPTY");
return;
}
Node tmpNode = head;
while (tmpNode != null) {
System.out.print(tmpNode.num + " -> ");
tmpNode = tmpNode.next;
}
}
private Node getLastNode() {
if (head == null) {
return null;
}
Node tmpNode = head;
while (tmpNode.next != null) {
tmpNode = tmpNode.next;
}
return tmpNode;
}
public static void main(String[] args) {
LinkedList myList = new LinkedList();
myList.print();
myList.append(35);
myList.append(33);
myList.print();
myList.delete(33);
myList.delete(35);
myList.delete(35);
myList.print();
}
}
Dies ist nur ein Beispiel, also möchten Sie das absolute Minimum implementieren, aber Generics, Comparable System.out.print
sind natürlich immer noch aktuelle Themen.
Verwandte Probleme
-
2
Shamos-Hoey-Algorithmus zur Überprüfung des Selbstschnittpunkts einer geschlossenen Form
-
2
HTTP-Anforderungspfad-Parser
-
4
Demetergesetz und Datenmodelle?
-
5
Thread-Safe und Lock-Free - Queue-Implementierung
-
4
Untertitel in einer größeren Sammlung finden?
-
2
Transaktionsberatung im Winterschlaf
-
1
Android ListAdapter-Designhinweise
-
3
Muster gegen anämisches Domänenmodell
-
6
Argumente in Konstruktoren, die mit Feldern übereinstimmen
-
3
Vereinfachter Android-Spinner