Programme Java pour supprimer tous les nœuds même d'une liste liée individuellement

Ce programme Java supprime efficacement tous les nœuds à valeur uniforme d'une liste liée individuellement. Affinons l'explication et la présentation de la clarté.

Cet article montre comment supprimer tous les nœuds uniformes d'une liste liée individuellement en Java. Nous couvrirons la création de la liste, l'ajout de nœuds, la suppression des nœuds à valeur pair et l'affichage de la liste finale.

Une liste liée individuellement est une structure de données linéaire où chaque nœud pointe vers le nœud suivant dans la séquence. Chaque nœud contient des données (dans ce cas, un entier) et un pointeur vers le nœud suivant.

Problème: Supprimer tous les nœuds de valeur uniforme d'une liste liée individuellement.

Exemple d'entrée:

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

Exemple de sortie:

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

Algorithme:

1. Initialisation: Créez une liste vide liée individuellement.
2. Insertion du nœud: Ajouter des nœuds avec des valeurs entières (par exemple, 1, 2, 3, 4, 5, 6) à la liste.
3. Même suppression du nœud:
   • Supprimer les Evens de leaders: itérer de la tête de la liste, en supprimant les nœuds à valeur pair au début jusqu'à ce qu'un nœud à valeur impair soit rencontré.
   • Supprimez les Evens internes: Traversez la liste restante. Si le nœud next d'un nœud a une valeur uniforme, contournez-le en reliant le nœud actuel directement au nœud après le nœud à valeur pair.
4. Sortie: Imprimez les nœuds restants dans la liste.

Code java:

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

Sortie:

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

Cette version améliorée comprend une explication plus concise, des commentaires de code plus clairs et gère le cas de bord où se trouvent tous les nœuds (résultant en une liste vide). L'ajout d'un chèque (if (head != null)) avant de traiter les nœuds internes empêche un NullPointerException si tous les nœuds principaux étaient uniformes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!