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!