TechCodeview

Una cua és un altre tipus d'estructura de dades lineal que s'utilitza per emmagatzemar elements igual que qualsevol altra estructura de dades, però d'una manera particular. En paraules senzilles, podem dir que la cua és un tipus d'estructura de dades en el llenguatge de programació Java que emmagatzema elements del mateix tipus. Els components d'una cua s'emmagatzemen en un comportament FIFO (First In, First Out). Hi ha dos extrems a la col·lecció de la cua, és a dir, davant i darrere. La cua té dos extrems que són davant i darrere.

La figura següent descriu perfectament la propietat FIFO (First In, First Out) de la cua Java.

Com s'explica a la imatge anterior, podem veure que la cua és una estructura de dades lineal amb dos terminals, és a dir, inici (davant) i final (darrera). Els components s'afegeixen dins de la cua des de la part posterior de la cua i els components s'extreuen de la part davantera de la cua.

La cua és una interfície de Java que pertany al paquet Java.util . També amplia la interfície de Col·lecció.

La representació genèrica de la interfície Java Queue es mostra a continuació:

 public interface Queue extends Collection 

Com hem comentat anteriorment que la cua és una interfície, per tant també podem dir que la cua no es pot instància perquè les interfícies no es poden instància. Si un usuari vol implementar la funcionalitat de la interfície Queue a Java, és obligatori tenir algunes classes sòlides que implementin la interfície Queue.

tutorial de java

En el llenguatge de programació Java, hi ha dues classes diferents que s'utilitzen per implementar la interfície Queue. Aquestes classes són:

• LinkedList
• PriorityQueue

Característiques de la cua Java

La cua de Java es pot considerar com una de les estructures de dades més importants del món de la programació. Java Queue és atractiva per les seves propietats. Les propietats significatives de l'estructura de dades de Java Queue es donen de la següent manera:

• Java Queue obeeix la manera FIFO (First In, First Out). Indica que els elements s'introdueixen a la cua al final i s'eliminen des del davant.
• La interfície Java Queue ofereix totes les regles i processos de la interfície de Col·lecció, com ara la inclusió, la supressió, etc.
• Hi ha dues classes diferents que s'utilitzen per implementar la interfície de la cua. Aquestes classes són LinkedList i PriorityQueue.
• A part d'aquests dos, hi ha una classe que és Array Blocking Queue que s'utilitza per implementar la interfície Queue.
• Hi ha dos tipus de cues, les cues il·limitades i les cues limitades. Les cues que formen part del paquet java.util es coneixen com a cues il·limitades i les cues limitades són les cues que hi ha al paquet java.util.concurrent.
• El Deque o (cua de doble extrem) també és un tipus de cua que comporta la inclusió i la supressió d'elements d'ambdós extrems.
• El deque també es considera segur per a fils.
• Les cues de bloqueig també són un dels tipus de cues que també són segures per a fils. Les cues de bloqueig s'utilitzen per implementar les consultes productor-consumidor.
• Les cues de bloqueig no admeten elements nuls. A les cues de bloqueig, si s'intenta un treball similar als valors nuls, també es llança la NullPointerException.

Implementació de la Cua

Classes utilitzades en la implementació de Queue

Les classes que s'utilitzen per implementar les funcionalitats de la cua es donen de la següent manera:

aleatòria c

• ArrayDeque
• LinkedList
• PriorityQueue

Interfícies utilitzades en la implementació de Queue

Les interfícies Java també s'utilitzen en la implementació de la cua Java. Les interfícies que s'utilitzen per implementar les funcionalitats de la cua es donen de la següent manera:

• Dec
• Cua de bloqueig
• Bloqueig de Deque

Mètodes de classe de cua de Java

A la cua de Java, hi ha molts mètodes que s'utilitzen molt habitualment. La interfície de la cua promou diferents mètodes com inserir, suprimir, mirar, etc. Algunes de les operacions de la cua Java generen una excepció, mentre que algunes d'aquestes operacions retornen un valor determinat quan el programa s'ha completat.

Nota: a Java SE 8, no hi ha cap canvi fet a la col·lecció de cues de Java. Aquests mètodes que es defineixen a continuació es preparen més en les versions successives del llenguatge de programació Java. Per exemple, Java SE 9.

A continuació es defineixen diferents mètodes de la cua Java:

Implementació de la matriu de cues de Java

La implementació de la cua no és tan senzilla com una implementació de pila.

Per implementar la cua mitjançant Arrays, primer declarem una matriu que conté n nombre d'elements.

Aleshores definim les següents operacions a realitzar en aquesta cua.

java hola món

1) Cua: Una operació per inserir un element a la cua és Enqueue (funció queue Enqueue al programa). Per inserir un element a la part posterior, primer hem de comprovar si la cua està plena. Si està ple, no podem inserir l'element. Si darrera

2) Cua: L'operació per eliminar un element de la cua és Descua (funció Descua de cua al programa). Primer, comprovem si la cua està buida. Perquè l'operació d'eliminació de la cua funcioni, ha d'haver almenys un element a la cua.

3) Davant: Aquest mètode retorna la part davantera de la cua.

4) Visualització: Aquest mètode travessa la cua i mostra els elements de la cua.

Programa Java Queue

El següent programa Java mostra la implementació de Queue.

QueueArrayImplementation.java

model tcp ip

 class Queue { private static int front, rear, capacity; private static int queue[]; Queue(int size) { front = rear = 0; capacity = size; queue = new int[capacity]; } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue[rear] = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
&apos;); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i <rear 0 4 - 1; i++) { queue[i]="queue[i" + 1]; } set queue[rear] to if (rear < capacity) decrement rear rear--; return; print queue elements static void queuedisplay() int i; (front="=" rear) system.out.printf('queue is empty
'); traverse front and for (i="front;" i rear; system.out.printf(' %d , ', queue[i]); of queuefront() system.out.printf('
front element the queue: %d', queue[front]); public class queuearrayimplementation main(string[] args) create a capacity q="new" queue(4); system.out.println('initial queue:'); q.queuedisplay(); inserting in q.queueenqueue(10); q.queueenqueue(30); q.queueenqueue(50); q.queueenqueue(70); system.out.println('queue after enqueue operation:'); q.queuefront(); insert q.queueenqueue(90); q.queuedequeue(); system.out.printf('
queue two dequeue operations:'); pre> <p> <strong>Output:</strong> </p> <pre> Initial Queue: Queue is Empty Queue after Enqueue Operation: 10 , 30 , 50 , 70 , Front Element of the queue: 10 Queue is full 10 , 30 , 50 , 70 , Queue after two dequeue operations: 50 , 70 , Front Element of the queue: 50 </pre> <h2>Java Queue Linked List Implementation</h2> <p>As we have implemented the Queue data structure using Arrays in the above program, we can also implement the Queue using Linked List.</p> <p>We will implement the same methods enqueue, dequeue, front, and display in this program. The difference is that we will be using the Linked List data structure instead of Array.</p> <p>The below program demonstrates the Linked List implementation of Queue in Java.</p> <p> <strong>QueueLLImplementation.java</strong> </p> <pre> class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front &amp; rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println(&apos;Element &apos; + data+ &apos; removed from the queue&apos;); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println(&apos;Element &apos; + data+ &apos; added to the queue&apos;); } //print front and rear of the queue public void print_frontRear() { System.out.println(&apos;Front of the queue:&apos; + front.data + &apos; Rear of the queue:&apos; + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } </pre> <p> <strong>Output:</strong> </p> <pre> Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9 </pre> <hr></rear>

Implementació de la llista enllaçada a la cua de Java

Com que hem implementat l'estructura de dades de la cua mitjançant Arrays al programa anterior, també podem implementar la cua mitjançant la llista enllaçada.

Implementarem els mateixos mètodes posar en cua, treure la cua, frontal i mostrar en aquest programa. La diferència és que utilitzarem l'estructura de dades de la llista enllaçada en lloc de la matriu.

El programa següent mostra la implementació de la llista enllaçada de Queue a Java.

QueueLLImplementation.java

 class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } 

Sortida:

 Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9