Liste de liens Java File d'attente

Question

À l'école, nous découvrons les structures de données abstraites. Notre tâche consistait à implémenter une liste chaînée dans Java. Pour une raison quelconque, ma file d'attente ne supprime que tous les deuxièmes éléments de la file d'attente. Peut-être que quelqu'un peut me dire mon erreur parce que je n'ai plus aucune idée. BTW je codage à l'aide BlueJ donc ne se interroger sur le démarrage du programme: D

La méthode dequeue

public Car dequeue() 
{ 
    Car c = new Car(head); 

    if(c != null){ 

      if (head.getLast() == tail) { 

       if(tail == null){ 

        head = null;        
        return c; 
       }      
       else {       
        head = tail;        
        tail = null;       
        return c;      
       } 
      }      
      else {      
       head = head.getLast();      
       return c;       
      } 
    }   
    return c; 
} 

L'objet Car

public class Car 
{ 
    private String driver; 
    private Car last; 

    public Car(String pDriver) 
    { 
     driver = pDriver; 
    } 

    public Car(Car c) 
    { 
     this.driver = c.getDriverName();   
     this.last = c.getLast(); 
    } 

    public String getDriverName() 
    { 
     return driver; 
    } 

    public Car getLast() 
    { 
     return last; 
    } 

    public void setLast(Car pLast) 
    { 
     last = pLast; 
    } 
} 

Answer 1

Jetez un oeil, sa file d'attente dynamique la mise en oeuvre.

Car (Il est juste une voiture, pas un noeud de file d'attente)

public class Car { 

    private String driver; 

    public Car(String driver) { 
     this.driver = driver; 
    } 

    @Override 
    public String toString() { 
     return "Car (" + driver + ")"; 
    } 

} 

QueueForCars (Met en œuvre une file d'attente qui ne traite que des voitures)

public class QueueForCars { 

    private class Node { 
     Car value; 
     Node previous; 
    } 

    private Node head; 
    private Node tail; 
    private int size; 

    public QueueForCars() { 
     tail = null; 
     head = null; 
     size = 0; 
    } 

    public void enqueue(Car value) { 

     Node newNode = new Node(); 
     newNode.value = value; 
     newNode.previous = null; 

     if (isEmpty()) { 
      head = newNode; 
      tail = newNode; 
     } else { 
      tail.previous = newNode; 
      tail = newNode; 
     } 

     size++; 

    } 

    public Car dequeue() { 

     if (!isEmpty()) { 

      Car value = head.value; 

      if (head == tail) { 
       head = null; 
       tail = null; 
      } else { 
       Node temp = head; 
       head = head.previous; 
       temp.previous = null; 
      } 

      size--; 
      return value; 

     } else { 
      return null; 
     } 

    } 

    public boolean isEmpty() { 
     return head == null; 
    } 

    public int getSize() { 
     return size; 
    } 

    @Override 
    public String toString() { 

     StringBuilder sb = new StringBuilder(); 

     if (!isEmpty()) { 

      Node current = head; 

      while (current != null) { 

       if (size == 1) { 
        sb.append(current.value).append(" <- head/tail\n"); 
       } else if (current == head) { 
        sb.append(current.value).append(" <- head\n"); 
       } else if (current == tail) { 
        sb.append(current.value).append(" <- tail\n"); 
       } else { 
        sb.append(current.value).append("\n"); 
       } 

       current = current.previous; 

      } 

     } else { 
      sb.append("empty queue!\n"); 
     } 

     return sb.toString(); 

    } 

} 

test (Teste la mise en œuvre)

public class Test { 

    public static void main(String[] args) { 

     QueueForCars queue = new QueueForCars(); 

     queue.enqueue(new Car("John")); 
     System.out.println(queue); 
     queue.enqueue(new Car("Mary")); 
     System.out.println(queue); 
     queue.enqueue(new Car("Richard")); 
     System.out.println(queue); 
     queue.enqueue(new Car("David")); 
     System.out.println(queue); 

     System.out.println(); 

     System.out.println("Dequeued: " + queue.dequeue()); 
     System.out.println(queue); 
     System.out.println("Dequeued: " + queue.dequeue()); 
     System.out.println(queue); 
     System.out.println("Dequeued: " + queue.dequeue()); 
     System.out.println(queue); 
     System.out.println("Dequeued: " + queue.dequeue()); 
     System.out.println(queue); 
     System.out.println("Dequeued: " + queue.dequeue()); // <- empty queue! 
     System.out.println(queue); 

    } 

} 

Si vous voulez une implémentation générique d'une file d'attente, par exemple, une file d'attente qui peut traiter tout type de données, votre mise en œuvre doit être quelque chose comme:

Queue (mise en œuvre générique d'une file d'attente)

public class Queue<Type> { 

    private class Node<Type> { 
     Type value; 
     Node<Type> previous; 
    } 

    private Node<Type> head; 
    private Node<Type> tail; 
    private int size; 

    public Queue() { 
     tail = null; 
     head = null; 
     size = 0; 
    } 

    public void enqueue(Type value) { 

     Node<Type> newNode = new Node<>(); 
     newNode.value = value; 
     newNode.previous = null; 

     if (isEmpty()) { 
      head = newNode; 
      tail = newNode; 
     } else { 
      tail.previous = newNode; 
      tail = newNode; 
     } 

     size++; 

    } 

    public Type dequeue() { 

     if (!isEmpty()) { 

      Type value = head.value; 

      if (head == tail) { 
       head = null; 
       tail = null; 
      } else { 
       Node<Type> temp = head; 
       head = head.previous; 
       temp.previous = null; 
      } 

      size--; 
      return value; 

     } else { 
      return null; 
     } 

    } 

    public boolean isEmpty() { 
     return head == null; 
    } 

    public int getSize() { 
     return size; 
    } 

    @Override 
    public String toString() { 

     StringBuilder sb = new StringBuilder(); 

     if (!isEmpty()) { 

      Node<Type> current = head; 

      while (current != null) { 

       if (size == 1) { 
        sb.append(current.value).append(" <- head/tail\n"); 
       } else if (current == head) { 
        sb.append(current.value).append(" <- head\n"); 
       } else if (current == tail) { 
        sb.append(current.value).append(" <- tail\n"); 
       } else { 
        sb.append(current.value).append("\n"); 
       } 

       current = current.previous; 

      } 

     } else { 
      sb.append("empty queue!\n"); 
     } 

     return sb.toString(); 

    } 

} 

Fruit (Une autre classe pour tester la file d'attente générique)

public class Fruit { 

    private String name; 
    private String color; 

    public Fruit(String name, String color) { 
     this.name = name; 
     this.color = color; 
    } 

    @Override 
    public String toString() { 
     return "Fruit (" + name + " is " + color + ")"; 
    } 

} 

test (Teste la file d'attente générique pour les voitures et les fruits)

public class Test { 

    public static void main(String[] args) { 

     Queue<Car> queueForCars = new Queue<>(); 

     queueForCars.enqueue(new Car("John")); 
     System.out.println(queueForCars); 
     queueForCars.enqueue(new Car("Mary")); 
     System.out.println(queueForCars); 
     queueForCars.enqueue(new Car("Richard")); 
     System.out.println(queueForCars); 
     queueForCars.enqueue(new Car("David")); 
     System.out.println(queueForCars); 

     System.out.println(); 

     Queue<Fruit> queueForFruits = new Queue<>(); 

     queueForFruits.enqueue(new Fruit("Apple", "red")); 
     System.out.println(queueForFruits); 
     queueForFruits.enqueue(new Fruit("Banana", "yellow")); 
     System.out.println(queueForFruits); 
     queueForFruits.enqueue(new Fruit("Lime", "green")); 
     System.out.println(queueForFruits); 

     System.out.println(); 


    } 

} 

Certains de mon code est redondant, par exemple, les constructeurs pour les files d'attente, car ils définissent les valeurs par défaut pour les membres des files d'attente, mais je pense De cette façon, il est préférable de comprendre quand vous apprenez. J'espère que cela peut vous aider!