La copie de code est la suivante:
/ **
* Liste liée à sens unique
*
* /
classe publique Nodelist <e> {
classe statique privée nœud <e> {// classe de nœud
E data; Données sur le nœud
Node <e> Suivant;
Nœud (e e) {
this.data = e;
this.next = null;
}
}
Node privé <e> tête; nœud d'en-tête de la liste liée
Node privé <e> dernier;
nœud privé <e> autre = null;
Longueur privé = 0; // Nombre de nœuds
/ **
* Méthode de construction non paramètre
* /
Public Nodelist () {
// Le nœud par défaut est vide
this.head = nouveau nœud <e> (null);
}
/ **
* Créez un nœud lors de l'initialisation
*
* Données @param
* données
* /
Public Nodelist (e Data) {
this.head = nouveau nœud <e> (données);
this.last = tête;
longueur ++;
}
/ **
* Ajouter un nœud (méthode d'insertion de queue)
*
* Données @param
* données
* /
public void add (e data) {
if (isEmpty ()) {
head = new nœud <e> (data);
dernier = tête;
longueur ++;
} autre {
Nœud <e> newNode = new node <e> (data);
Last.Next = newNode;
dernier = newNode;
}
}
/ **
* Obtenez les données à l'index (l'erreur d'entrée d'index lance une exception hors limites)
* index de l'indice @param
* @return Data à Index
* /
public e get (int index) {
if (index <0 || index> longueur) {
lancer un nouvel indexoutofboundSexception ("index:" + index);
}
Autre = tête;
pour (int i = 0; i <index; i ++) {
autre = autre.Next;
}
retourner autre.data;
}
/ **
* Une nouvelle valeur remplace la valeur ancienne
* @return Le succès est vrai, non trouvé comme faux
* /
ensemble booléen public (e oldvalue, e newValue) {
Autre = tête;
tandis que (autre! = null) {
if (autre.data.equals (oldvalue)) {
autre.data = newValue;
Retour Vrai;
}
autre = autre.Next;
}
retourne false;
}
/ **
* Insérez un élément après avoir spécifié l'élément
*
* Données @param
* Élément spécifié
* @param insertdata
* Éléments qui doivent être insérés
* @return false est élément non trouvé, c'est vrai que l'insertion est réussie
* /
public booléen add (e data, e insertData) {
Autre = tête;
tandis que (autre! = null) {
if (autre.data.equals (data)) {
Node <e> newNode = new node <e> (insertData);
Nœud <e> temp = autre.next;
newnode.next = temp;
autre.Next = newNode;
longueur ++;
Retour Vrai;
}
autre = autre.Next;
}
retourne false;
}
/ **
* Si cet élément est inclus dans la liste liée
* @return inclus comme vrai, pas faux
* /
Boolean public contient (e data) {
Autre = tête;
tandis que (autre! = null) {
if (autre.data.equals (data)) {
Retour Vrai;
}
autre = autre.Next;
}
retourne false;
}
/ **
* Retirez l'élément spécifié
* Éléments de données @param qui doivent être supprimés
* @return n'existe pas et est vrai pour le succès
* /
Public Boolean Supprimer (e Data) {
Autre = tête;
Nœud <e> temp = tête; // variable temporaire, utilisée pour enregistrer le nœud précédent
tandis que (autre! = null) {
if (autre.data.equals (data)) {
temp.Next = autre.Next;
longueur--;
Retour Vrai;
}
temp = autre;
autre = autre.Next;
}
retourne false;
}
/ **
* Déterminez si la liste liée est vide
*
* @return vide est vrai, non vide est faux
* /
public booléen iSempty () {
longueur de retour == 0;
}
/ **
* Effacer la liste des liens
* /
public void clear () {
this.head = null;
this.length = 0;
}
/ **
* Sortir tous les nœuds
* /
public void printLink () {
if (isEmpty ()) {
System.out.println ("Liste liée vide");
}autre{
Autre = tête;
tandis que (autre! = null) {
System.out.print (autre.data);
autre = autre.Next;
}
System.out.println ();
}
}
}