Comment puis-je faire ce Java affichage des files d'attente() la méthode de travail avec tous les tableau des tailles au lieu de seulement [5]?
//Queue.java
//demonstrates queue
//to run this program: C>java QueueApp
class Queue
{
private int maxSize;
private long[] queArray;
private int front;
private int rear;
private int nItems;
public Queue(int s) //constructor
{
maxSize = s;
queArray = new long[maxSize];
front = 0;
rear = -1;
nItems = 0;
}
public void insert(long j)
{
if(rear == maxSize-1)
rear = -1;
queArray[++rear] = j;
nItems++;
}
public long remove()
{
long temp = queArray[front++];
if(front == maxSize)
front = 0;
nItems--;
return temp;
}
public long peekFront()
{
return queArray[front];
}
public boolean isEmpty() //true if queue is empty
{
return (nItems==0);
}
public boolean isFull() //true if queue is full
{
return (nItems==maxSize);
}
public int size() //number of items in queue
{
return nItems;
}
public void display()
{ int startFront = front;
for (int j = front ;j <nItems; j++ )
{
System.out.println(queArray[j]);
if (j == nItems-1 )
{ j=0;
System.out.println(queArray[j]);
}
if (j==startFront-1)
return;
}
}
}
class QueueApp
{
public static void main(String[] args)
{
Queue theQueue = new Queue(5); //queue holds 5 items
theQueue.insert(10); //insert 4 items
theQueue.insert(20);
theQueue.insert(30);
theQueue.insert(40);
theQueue.remove(); //remove 3 items
theQueue.remove(); // (10, 20, 30)
theQueue.remove();
theQueue.insert(50); //insert 4 more items
theQueue.insert(60); // (wraps around)
theQueue.insert(70);
theQueue.insert(80);
theQueue.display();
while( !theQueue.isEmpty() ) //remove and display
{ // all items
long n = theQueue.remove(); //(40, 50, 60, 70, 80)
System.out.print(n);
System.out.print(" ");
}
System.out.println("");
} //end main()
} //end class QueueApp
Bon d'accord, c'est la base, du livre, de la file d'attente de code. Je suis de la tentative de créer une méthode d'affichage qui affiche la file d'attente dans l'ordre, de l'avant vers l'arrière. (C'est une affectation, je sais que ce n'est pas pratique....) Si je lance le programme, il affiche la file d'attente dans l'ordre de l'avant à l'arrière(c'est du moins ce que je crois que j'ai fait). Le problème que j'ai est que si je change la nItems, il cesse de travailler. Par exemple, si vous ajoutez la ligne de code, theQueue.remove(); juste au-dessus de l'appel à l'affichage, la méthode de cesse de travailler, je sais que c'est parce que le front est maintenant = 4, au lieu de 3,et il n'entrera pas la pour la méthode qui doit avant < nItems, 4<4 n'est pas vrai, alors la boucle for ne prend pas l'initiative.
- La file d'attente theQueue = new File d'attente(5); ne pas coder en dur taille de file d'attente de 5, laissez entrée décider de la taille. Demandez pour une taille de file d'attente à l'aide d'un Scanner.
Vous devez vous connecter pour publier un commentaire.
Simplement utiliser quelque chose comme:
%
est l'opérateur modulo, une.k.un. le reste. Supposons quei
incréments indéfiniment, les valeurs dei % 5
sera 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, etc.À mon avis, vous êtes en utilisant un trop grand nombre de variables pour lesquelles vous n'avez pas besoin. Vous avez seulement besoin de la taille de File d'attente et son nombre d'éléments.
Donc ce qui se passe en ce moment est que
j
est la position de l'élément dans votre tableau, qui est différent du nombre d'éléments que vous avez imprimé jusqu'à présent.Vous devez soit utiliser un autre indice de compter le nombre d'éléments que vous avez imprimé ou vérifier si vous êtes à la fin en comparant
j
àrear
.Lorsque la file d'attente est pleine (à l'arrière == maxSize - 1) et de vous faire un insert, il remplacera le premier
item, je pense que la ligne nItems++ ne doit pas être incrémenté lorsque la file d'attente est déjà pleine.
Edit: Éviter le module opérations lorsque vous n'en avez pas besoin, ils consomment beaucoup de cpu.
Le magasin de sauvegarde de votre file d'attente est :
Pourquoi ne pas plutôt utiliser :
et laissez
List
soucier du redimensionnement d'effort aprèsadd/remove
opérations. Votre file d'attente en cours de mise en œuvre a besoin de savoir exactement combien d'éléments sont dans la file d'attente de la construction. C'est assez gênant pour les clients l'utilisation de cette API.Vous pouvez instancier la queArray comme :
dans votre constructeur. Une fois que vous comprenez vraiment ce code, vous pouvez alors passer à vous soucier de le re-dimensionnement de la logique de vous-même.
List
ne changera rien.