5 votes

Pourquoi avoir une classe parent pour la liste chaînée

C'est une question générale, peut-être à propos du concept de POO. Je viens juste de commencer avec l'implémentation de DS en JAVA. J'essaie d'implémenter une liste chaînée et sur toutes les ressources en ligne, je vois une pratique similaire :

  1. Crée une classe node.
  2. Crée une classe Linked List qui a un objet node.

J'ai vu la même chose pour les piles, files et arbres. Ma question est, si j'implémente LinkedList en n'ayant qu'une seule classe qui ressemble à ceci :

 class LinkList {
     int data;
     LinkList next; }

Je suis toujours capable de faire toutes les opérations. Donc le concept d'avoir une deuxième classe qui contient une racine ou un en-tête est seulement pour un but de POO ou autre chose ? J'ai écrit le code suivant et il fonctionne très bien sans avoir besoin d'un pointeur d'en-tête. J'utilise une variable de référence dans toutes les méthodes et l'objet de la classe principale garde toujours la trace de la tête.

/* package codechef; // ne placez pas le nom du package ! */

import java.util.*;
import java.lang.*;
import java.io.*;

class LinkList {
    int data;
    LinkList next;

    LinkList(){
        data = 0;
        next = null;
    }

    LinkList(int data) {
        this.data = data;
        next = null;
    }
    LinkList insertAtBegin(int data){
        LinkList newBegin = new LinkList(data);
        newBegin.next = this;
        return newBegin;
    }
    void insertAtPlace(int data, int insertData){
        LinkList newNode = new LinkList(insertData);
        LinkList iterator = this;
        while(iterator!=null && iterator.data!=data){
            iterator = iterator.next;
        }
        if(iterator.data == data)
        {
            newNode.next = iterator.next;
            iterator.next = newNode;
        }
    }
    void insertAtLast(int data) {
        if(next == null){
            next = new LinkList(data);
        }
        else{
            next.insertAtLast(data);
        }
    }

}

/* Le nom de la classe doit être "Main" uniquement si la classe est publique. */
class Codechef
{
    public static void main (String[] args) throws java.lang.Exception
    {
        // votre code va ici
        LinkList linkList = new LinkList(6);
        linkList.insertAtLast(5);
        linkList.insertAtLast(3);
        linkList.insertAtLast(2);
        linkList.insertAtLast(1);

        linkList = linkList.insertAtBegin(10);
        LinkList iterator = linkList;
        while(iterator!=null){
            System.out.print(iterator.data);
            iterator = iterator.next;
        }
        System.out.print("\n");
        linkList.insertAtPlace(5,-1);
        iterator = linkList;
        while(iterator!=null){
            System.out.print(iterator.data);
            iterator = iterator.next;
        }
    }
}

3voto

Eran Points 35360

Vous devez conserver la trace de la tête de la liste chaînée quelque part. Sinon, comment itérer sur toute la liste ou rechercher un élément dans la liste ?

Si votre LinkList est essentiellement un nœud (avec des données et une référence au nœud suivant), vous devrez implémenter toutes les opérations de liste chaînée (ajout, suppression, etc...) dans une classe distincte qui garde trace du nœud de tête de la liste.

Cela vous ramène à une classe de liste chaînée qui utilise une classe de nœud.

Quant au code que vous avez ajouté, LinkList insertAtBegin(int data) n'insérera un nœud qu'au début de la liste si vous l'appelez sur le premier nœud de la liste. Mais rien ne vous empêche de l'appeler sur n'importe quel nœud de la liste, auquel cas il renverra essentiellement une nouvelle liste qui commence par les nouveaux éléments et se termine par une sous-liste de la liste d'origine.

1voto

Maurice Perry Points 5513

Il y a plusieurs raisons d'avoir deux classes:

  • pour distinguer la notion d'une liste et celle d'un nœud unique,
  • pour éviter le retour maladroit du nœud de tête de chaque méthode,
  • pour éviter de laisser au client de la classe la responsabilité de suivre le nœud de tête,
  • pour masquer les détails de l'implémentation, de sorte que la classe pourrait être plus facilement remplacée par une équivalente,
  • etc...

0voto

ArchyInUse Points 11

Votre classe LinkList ne serait qu'une classe de nœud dans le premier exemple, car elle contient les données et le nœud qui suit

Le but général d'avoir une classe LinkedList est d'avoir un "emballage" pour la liste, c'est simplement une classe qui contient la tête de la liste (qui dans le cas d'une liste chaînée, représente la liste) et éventuellement certaines fonctionnalités telles qu'une fonction de recherche ou tout ce dont vous auriez besoin.

donc dans votre cas (2ème exemple), c'est simplement une classe d'emballage qui implémente certaines fonctionnalités supplémentaires (insertAtBegin(), insertAtPlace() et insertAtLast())

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X