Java -Programm zum Löschen aller sogar Knoten aus einer einzig verknüpften Liste

Dieses Java-Programm entfernt effizient alle ausgewogenen Knoten aus einer einzig verknüpften Liste. Lassen Sie uns die Erklärung und Präsentation für Klarheit verfeinern.

Dieser Artikel zeigt, wie alle gleichnummerierten Knoten aus einer einzig verknüpften Liste in Java entfernt werden. Wir werden das Erstellen der Liste erstellen, Knoten hinzufügen, ausgezeichnete Knoten löschen und die endgültige Liste anzeigen.

Eine einzeln verknüpfte Liste ist eine lineare Datenstruktur, in der jeder Knoten in der Sequenz auf den nächsten Knoten zeigt. Jeder Knoten enthält Daten (in diesem Fall eine Ganzzahl) und einen Zeiger auf den nächsten Knoten.

Problem: Alle ausgewogenen Knoten aus einer einzig verknüpften Liste löschen.

Eingabebeispiel:

<code>Original List: 1 2 3 4 5 6</code>

Ausgabebeispiel:

<code>Original List: 1 2 3 4 5 6
List after deleting even nodes: 1 3 5</code>

Algorithmus:

1. Initialisierung: Erstellen Sie eine leere einzig verknüpfte Liste.
2. Knoteninsertion: Knoten mit ganzzahligen Werten (z. B. 1, 2, 3, 4, 5, 6) zur Liste.
3. sogar Knotenentfernung:
   • Entfernen Sie führende Evens: Iterieren Sie vom Kopf der Liste, und entfernen
   • Entfernen Sie die internen Evens: Durchqueren Sie die verbleibende Liste. Wenn der -Knoten eines Knotens einen gleichmäßigen Wert hat, umgehen Sie ihn durch Verknüpfen des aktuellen Knotens direkt mit dem Knoten nach dem gleichwertigen Knoten. next
Ausgabe:
4. Drucken Sie die verbleibenden Knoten in der Liste.

Java -Code:

public class LinkedList {
    static class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    Node head;

    public void insert(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }

    public void deleteEvenNodes() {
        //Remove leading even nodes
        while (head != null && head.data % 2 == 0) {
            head = head.next;
        }

        //Remove internal even nodes
        if (head != null) {  //Check if list is not empty after removing leading evens
            Node current = head;
            while (current != null && current.next != null) {
                if (current.next.data % 2 == 0) {
                    current.next = current.next.next;
                } else {
                    current = current.next;
                }
            }
        }
    }

    public void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.insert(1);
        list.insert(2);
        list.insert(3);
        list.insert(4);
        list.insert(5);
        list.insert(6);

        System.out.println("Original List:");
        list.printList();

        list.deleteEvenNodes();

        System.out.println("List after deleting even nodes:");
        list.printList();
    }
}

Ausgabe:

Diese verbesserte Version enthält eine prägnantere Erklärung, klarere Code -Kommentare und verarbeitet den Randfall, in dem alle Knoten gleichmäßig sind (was zu einer leeren Liste führt). Die Hinzufügung eines Schecks (

<code>Original List:
1 2 3 4 5 6 
List after deleting even nodes:
1 3 5 </code>

), bevor die Verarbeitung interner Knoten ein

verhindert, wenn alle führenden Knoten gleichmäßig waren. if (head != null)

Das obige ist der detaillierte Inhalt vonJava -Programm zum Löschen aller sogar Knoten aus einer einzig verknüpften Liste. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!