Lista vinculada en Java -- java campo con linked-list campo con reinventing-the-wheel camp codereview Relacionados El problema

Linked List in Java


2
vote

problema

Español

Aquí está mi implementación de una lista vinculada. Creo que debe ser eficiente debido al nodo de la cabeza y el seguimiento del nodo trasero. Por favor, haga comentarios sobre mi implementación de la lista vinculada.

  import java.util.Scanner;  public class LinkedList{    private static LinkedList head;   private static LinkedList rear;   private LinkedList next;   private Object data;    public LinkedList(Object data,LinkedList next ){    this.next = next;     this.data = data;    }    public LinkedList(){     this.head = new LinkedList(null);     this.next = null;     this.data = null;   }      public LinkedList(Object data){     this.next = null;     this.data = data;   }   public Object getData(){    return this.data ;  }    public void setData(Object data){     this.data = data;   }    public LinkedList getNext(){     return this.next;   }    public void SetNext(LinkedList next){     this.next = next;   }    public void add(Object data){        if(head.next == null){        head.next = new LinkedList(data);       rear = head;     }      else{       LinkedList temp = head.next;         while(temp.next != null){           temp = temp.next;         }       temp.next = new LinkedList(data);       rear = temp.next;     }     }    public void remove(Object data){      LinkedList previous = new LinkedList(null);     LinkedList temp = new LinkedList(null);      if(head.next == null){       System.out.println("There is nothing to remove from the list");       return;     }     temp = head;      while(temp.next != null){       previous = temp;       temp = temp.next;       if(temp.data == data){         if(temp.next == null){           rear = previous;         }         previous.next = temp.next;         return;       }        }      System.out.println("That data is not in the list");       }       public void printAll(){      if(head.next == null){       System.out.println("The list is empty. There is nothing to print");       return;     }        LinkedList temp = head.next;       if(temp.data != null){         System.out.println(temp.data);        }       else{         System.out.println("empty data link  ");         return;}         while(temp.next != null){          temp = temp.next;          if(temp.data != null){         System.out.println(temp.data);       }       else{          System.out.println("empty data link  ");       }        }        return;       }    public void addFirst(Object data){      if(head.next == null){        head.next = new LinkedList(data);      }      else{        LinkedList temp = new LinkedList(data);       temp.next = head.next;       head.next = temp;        }    }    public void addLast(Object data){      if(rear == head){        addFirst(data);     }      else{       rear.next = new LinkedList(data);     }     }     public static void main(String args[]){      LinkedList list = new LinkedList();     Scanner scanner = new Scanner(System.in);      while(true){       System.out.println(" Enter a command:  1. add [data] 2.remove [data] 3.printall  ");         String command = scanner.next();        if(command.equalsIgnoreCase("add")){          list.add(scanner.nextInt());        }       if(command.equalsIgnoreCase("remove")){          list.remove(scanner.nextInt());        }       if(command.equalsIgnoreCase("printall")){          list.printAll();        }      }    }      }   
Original en ingles

Here is my implementation of a Linked List. I think it should be efficient because of the head node and rear node tracking. Please give any feedback on my implementation of Linked List.

import java.util.Scanner;  public class LinkedList{    private static LinkedList head;   private static LinkedList rear;   private LinkedList next;   private Object data;    public LinkedList(Object data,LinkedList next ){    this.next = next;     this.data = data;    }    public LinkedList(){     this.head = new LinkedList(null);     this.next = null;     this.data = null;   }      public LinkedList(Object data){     this.next = null;     this.data = data;   }   public Object getData(){    return this.data ;  }    public void setData(Object data){     this.data = data;   }    public LinkedList getNext(){     return this.next;   }    public void SetNext(LinkedList next){     this.next = next;   }    public void add(Object data){        if(head.next == null){        head.next = new LinkedList(data);       rear = head;     }      else{       LinkedList temp = head.next;         while(temp.next != null){           temp = temp.next;         }       temp.next = new LinkedList(data);       rear = temp.next;     }     }    public void remove(Object data){      LinkedList previous = new LinkedList(null);     LinkedList temp = new LinkedList(null);      if(head.next == null){       System.out.println("There is nothing to remove from the list");       return;     }     temp = head;      while(temp.next != null){       previous = temp;       temp = temp.next;       if(temp.data == data){         if(temp.next == null){           rear = previous;         }         previous.next = temp.next;         return;       }        }      System.out.println("That data is not in the list");       }       public void printAll(){      if(head.next == null){       System.out.println("The list is empty. There is nothing to print");       return;     }        LinkedList temp = head.next;       if(temp.data != null){         System.out.println(temp.data);        }       else{         System.out.println("empty data link\n\n");         return;}         while(temp.next != null){          temp = temp.next;          if(temp.data != null){         System.out.println(temp.data);       }       else{          System.out.println("empty data link\n\n");       }        }        return;       }    public void addFirst(Object data){      if(head.next == null){        head.next = new LinkedList(data);      }      else{        LinkedList temp = new LinkedList(data);       temp.next = head.next;       head.next = temp;        }    }    public void addLast(Object data){      if(rear == head){        addFirst(data);     }      else{       rear.next = new LinkedList(data);     }     }     public static void main(String args[]){      LinkedList list = new LinkedList();     Scanner scanner = new Scanner(System.in);      while(true){       System.out.println("\nEnter a command: \n1. add [data]\n2.remove [data]\n3.printall\n\n");         String command = scanner.next();        if(command.equalsIgnoreCase("add")){          list.add(scanner.nextInt());        }       if(command.equalsIgnoreCase("remove")){          list.remove(scanner.nextInt());        }       if(command.equalsIgnoreCase("printall")){          list.printAll();        }      }    }      } 
        
 
 

Lista de respuestas

2
 
vote

estático

Lo que más se destaca sobre su implementación es que está utilizando miembros estáticos para el head y rear de su lista. Esto significa que se comparten entre todas las instancias del LinkedList . En efecto, esto significa que solo puede tener una lista en su programa, que es una limitación que probablemente desee evitar.

Separación de preocupaciones

Típicamente, hay una separación entre los elementos dentro de una lista y la lista en sí. En su implementación, su clase LinkedList8 no solo es responsable de las operaciones que uno podría realizar en una lista, como remove , también es responsable de almacenar datos para un enlace específico dentro de la lista. Esto es confuso. Cosa de crear un def cycle(str_num): return [str_num[i:]+str_num[:i] for i in range(len(str_num))] def circularPrime(n): ss = str(n); if any(i in exlude for i in ss): return 0 return all(int(i) in primes for i in cycle(ss)) 0 def cycle(str_num): return [str_num[i:]+str_num[:i] for i in range(len(str_num))] def circularPrime(n): ss = str(n); if any(i in exlude for i in ss): return 0 return all(int(i) in primes for i in cycle(ss)) 1 Representa un solo enlace / nodo en la cadena y es responsable de almacenar un puntero al siguiente enlace / nodo y los datos de este Enlace. Luego, su clase de Linkedlist se hace responsable de la gestión de enlaces, no de almacenamiento directo de datos.

imprime vs excepciones

En lugar de métodos como def cycle(str_num): return [str_num[i:]+str_num[:i] for i in range(len(str_num))] def circularPrime(n): ss = str(n); if any(i in exlude for i in ss): return 0 return all(int(i) in primes for i in cycle(ss)) 2 Imprimir en la consola, es posible que desee considerar lanzar excepciones para indicar que el cliente de la clase ha intentado hacer algo inválido. Actualmente, como def cycle(str_num): return [str_num[i:]+str_num[:i] for i in range(len(str_num))] def circularPrime(n): ss = str(n); if any(i in exlude for i in ss): return 0 return all(int(i) in primes for i in cycle(ss)) 3 devuelve el vacío, no hay forma de que el código de llamada sepa que se intenta hacer algo inválido.

printall

Printall realmente no pertenece a una implementación de la lista (aunque a menudo se agrega cuando se está escribiendo la lista para fines de aprendizaje). El suministro de métodos de iteración debe ser suficiente para que el cliente realice impresión si es necesario. De esa manera, la lista puede concentrarse en ser una lista y el cliente puede concentrarse en interactuar con el usuario si lo desean.

objeto vs genéricos

¿Realmente desea permitir que se coloquen múltiples objetos que no están relacionados en su lista? Si no, entonces, en lugar de tener una lista de Tipo def cycle(str_num): return [str_num[i:]+str_num[:i] for i in range(len(str_num))] def circularPrime(n): ss = str(n); if any(i in exlude for i in ss): return 0 return all(int(i) in primes for i in cycle(ss)) 4 , estaría mejor buscando haber escrito como una lista genérica para que pueda almacenar artículos de forma segura.

 

Static

The thing that stands out most about your implementation is that you're using static members for the head and rear of your list. This means that they're shared amongst all instances of the LinkedList class. In effect, this means that you can only have one list in your program which is a limitation that you probably want to avoid.

Separation of concerns

Typically, there is a separation between the items within a list and the list itself. In your implementation, Your LinkedList class is not only responsible for operations that one might perform on a list, like remove, it is also responsible for storing data for a specific link within the list. This is confusing. Thing about creating a Node or Link class that represents a single link/node in the chain and is responsible for storing a pointer to the next Link/Node and the data for this link. Then your LinkedList class becomes responsible for link management, not direct data storage.

Prints Vs Exceptions

Rather than methods like remove print to the console, you might want to consider throwing exceptions to indicate that the client of the class has attempted to do something invalid. Currently, as remove returns void, there's no way for the calling code to know that it's tried to do something invalid.

Printall

Printall doesn't really belong in a list implementation (although it's often added when the list is being written for learning purposes). Providing iteration methods should be enough for the client to perform printing if required. That way the list can concentrate on being a list and the client can concentrate on interacting with the user if they want to.

Object Vs Generics

Do you really want to allow multiple objects that are unrelated to be stored in your list? If not, then rather than having a list of type Object, you'd be better off looking into writing it as a generic list so that it can store items in a type safe way.

 
 
2
 
vote

Cosas pequeñas

Styling

Debe eliminar las líneas vacías entre los comandos. Están contaminando el código.

Ocultar detalles de implementación

EVITAR public Modificador en los detalles de la implementación.

  /*     it is not good for a public API     <hide-this>  */     public Object getData() {         return this.data;     }       public void setData(Object data) {         this.data = data;     }      public LinkedList getNext() {         return this.next;     }      public void SetNext(LinkedList next) {         this.next = next;     } // </hide-this>   

SUSTITUTO while a for

prefiero

      for (LinkedList temp = head; temp.next != null; temp = temp.next)    

en lugar de

      LinkedList temp = head;     while (temp.next != null) {         // ...         temp = temp.next;   

Ahora, las cosas importantes

Eliminar el método superfluo

El método add65544336 es superfluo. Puede decidir por un comportamiento predeterminado: addLast o addFirst . Por cierto, addLast no funciona.

Mantener la cabeza sin datos

La implementación común de Linkedlist es mantener un nodo principal sin datos. Esto mantendría el código más sencillo. Siempre puedes confiar en que la cabeza estaría allí.

Simplify lo más posible

Comparar ...

  /*     it is not good for a public API     <hide-this>  */     public Object getData() {         return this.data;     }       public void setData(Object data) {         this.data = data;     }      public LinkedList getNext() {         return this.next;     }      public void SetNext(LinkedList next) {         this.next = next;     } // </hide-this> 0  

... con ...

  /*     it is not good for a public API     <hide-this>  */     public Object getData() {         return this.data;     }       public void setData(Object data) {         this.data = data;     }      public LinkedList getNext() {         return this.next;     }      public void SetNext(LinkedList next) {         this.next = next;     } // </hide-this> 1  

Versión revisada

  /*     it is not good for a public API     <hide-this>  */     public Object getData() {         return this.data;     }       public void setData(Object data) {         this.data = data;     }      public LinkedList getNext() {         return this.next;     }      public void SetNext(LinkedList next) {         this.next = next;     } // </hide-this> 2  
 

Small things

Styling

You should remove empty lines between commands. They are polluting the code.

Hide implementation details

Avoid public modifier on implementation details.

/*     it is not good for a public API     <hide-this>  */     public Object getData() {         return this.data;     }       public void setData(Object data) {         this.data = data;     }      public LinkedList getNext() {         return this.next;     }      public void SetNext(LinkedList next) {         this.next = next;     } // </hide-this> 

Substitute while to for

Prefer

    for (LinkedList temp = head; temp.next != null; temp = temp.next)  

Instead of

    LinkedList temp = head;     while (temp.next != null) {         // ...         temp = temp.next; 

Now, the important things

Remove superfluous method

The add method is superfluous. You can decide by one default behavior: addLast or addFirst. By the way, addLast is not working.

Keep head without data

The common implementation of LinkedList is to keep a head node without data. This would keep code simpler. You can always trust that head would be there.

Simplify as much as possible

Compare...

  public void addFirst(Object data){      if(head.next == null){        head.next = new LinkedList(data);      }      else{        LinkedList temp = new LinkedList(data);       temp.next = head.next;       head.next = temp;        }    } 

...with...

public void addFirst(Object data) {         LinkedList temp = new LinkedList(data);         temp.next = head.next;         head.next = temp; } 

Reviewed version

private final static LinkedList head = new LinkedList(null); private static LinkedList rear = head;  private LinkedList next; private Object data;  public LinkedList() {     this(null); }   public LinkedList(Object data) {     this.next = null;     this.data = data; }  public void remove(Object data) {     if (head.next == null) {         System.out.println("There is nothing to remove from the list");         return;     }     LinkedList previous = head;     for (LinkedList temp = head.next; temp != null; temp = temp.next) {         if (temp.data.equals(data)) {             if (temp.next == null) {                 rear = previous;             }             previous.next = temp.next;             return;         }         previous = temp;     }     System.out.println("That data is not in the list"); }  public void addFirst(Object data) {         LinkedList temp = new LinkedList(data);         temp.next = head.next;         head.next = temp; }  public void addLast(Object data) {     rear.next = new LinkedList(data);     rear = rear.next; } 
 
 
0
 
vote

Los puntos más finos ya se explicaron, pero el punto crucial es lo siguiente:

Debe haber una estructura de datos para toda la lista de enlaces linked , y internamente una otra estructura de datos que representa un solo enlace en la lista, a menudo llamada nodo.

Usted tiene la lista enlazada completa como variables estáticas (por lo que hay una sola lista disponible a nivel mundial), y Linkedlist reproduce más de un rol, ambos enlaces y en la lista de acceso.

 

The finer points were already explained, but the crucial point is the following:

There should be one data structure for the entire LinkedList, and internally an other data structure representing a single link in the list, often called Node.

You have the entire linked list as static variables (so there is one single list available globally), and LinkedList plays more than one role, both Link and List access.

 
 

Relacionados problema

12  Autenticación simple en ASP.NET MVC 5  ( Simple authentication in asp net mvc 5 ) 
Estoy construyendo una aplicación ASP.NET MVC 5 y, por razones que son irrelevantes en este punto, estoy intentando construir mi propio medio para autenticar ...

4  Iniciar sesión en la base de datos con el núcleo ASP.NET  ( Logging into database with asp net core ) 
En el Container9 de mi aplicación ASP.NET Core Quiero configurar el 99887766655443330 para que inicie sesión en la base de datos. Por lo tanto, creo despu...

6  C Getline () Implementación  ( C getline implementation ) 
Estoy practicando mi codificación C y quería implementar mi propia versión del getline Función en C para fines de aprendizaje. Me gustaría una revisión sobr...

3  Implementando de forma libre, crecer y encogerse en una tabla de hash  ( Implementing cleartable grow and shrink on a hash table ) 
He pasado por preguntas anteriores sobre la implementación de tablas de hash en Python, pero tengo algo más específico. Estoy manejando colisiones con sondeo ...

2  Fusionar la implementación de Sort Java  ( Merge sort java implementation ) 
¿Puede alguien revisar mi implementación de tipo de fusión en Java? ¿Es bueno / malo y puede mejorarse más? public class MyMergeSort { private int [] d...

11  Yaai (otro de otra implementación)  ( Yaai yet another any implementation ) 
Soy un desarrollador de juegos de C # actualmente aprendiendo C ++ y este es mi proyecto de segundo Big-ish (el primero es un Implementación vectorial ). E...

5  Implementar el análisis de STRTOD  ( Implement strtod parsing ) 
en este comentario la OP escribió, Soy un novato, así que me gustaría saber ¿Cómo me gustaría analizar los números / argumentos de Negetive? en Esta ...

5  Método de cálculo del día del año  ( Day of year calculation method ) 
El ejercicio que quería resolver es de aquí . Copiando desde esa página: public static int dayOfYear(int month, int dayOfMonth, int year) { if (month...

9  Comandos de Linux en Python  ( Linux commands in python ) 
He decidido escribir algunos comandos de Linux en Python. A continuación se muestra una lista, junto con algunas restricciones (si no está familiarizado con L...

0  Producto cartesiano de dos tuplas - Python  ( Cartesian product of two tuples python ) 
Estoy resolviendo el ejercicio 4 de Discusión 3 de CS 61A (2012) de Berkley (2012) (consulte la página 4): Rellene la definición de cartesian_product . ...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos