TechCodeview

O coadă este un alt tip de structură de date liniară care este utilizată pentru a stoca elemente la fel ca orice altă structură de date, dar într-un anumit mod. Cu cuvinte simple, putem spune că coada este un tip de structură de date în limbajul de programare Java care stochează elemente de același fel. Componentele dintr-o coadă sunt stocate într-un comportament FIFO (First In, First Out). Există două capete în colecția de coadă, și anume, față și spate. Coada are două capete, care este în față și în spate.

Următoarea figură descrie perfect proprietatea FIFO (First In, First Out) a cozii Java.

După cum sa explicat în imaginea precedentă, putem vedea că coada este o structură de date liniară cu două terminale, adică start (față) și sfârșit (spate). Componentele sunt adăugate în interiorul cozii de la capătul din spate al cozii, iar componentele sunt extrase din partea din față a cozii.

Coada este o interfață în Java care aparține pachetului Java.util . De asemenea, extinde interfața Collection.

Reprezentarea generică a interfeței Java Queue este prezentată mai jos:

java sort arraylist

 public interface Queue extends Collection 

După cum am discutat mai sus că coada este o interfață, de aceea putem spune și că coada nu poate fi instanțiată deoarece interfețele nu pot fi instanțiate. Dacă un utilizator dorește să implementeze funcționalitatea interfeței Queue în Java, atunci este obligatoriu să aibă niște clase solide care implementează interfața Queue.

În limbajul de programare Java, există două clase diferite care sunt utilizate pentru a implementa interfața Queue. Aceste clase sunt:

unire vs unire toate

• LinkedList
• PriorityQueue

Caracteristicile cozii Java

Coada Java poate fi considerată una dintre cele mai importante structuri de date din lumea programării. Java Queue este atractivă datorită proprietăților sale. Proprietățile semnificative ale structurii de date Java Queue sunt prezentate după cum urmează:

• Java Queue respectă modul FIFO (First In, First Out). Indică faptul că elementele sunt introduse în coadă la sfârșit și eliminate din față.
• Interfața Java Queue oferă toate regulile și procesele interfeței Collection, cum ar fi includerea, ștergerea etc.
• Există două clase diferite care sunt utilizate pentru a implementa interfața Queue. Aceste clase sunt LinkedList și PriorityQueue.
• În afară de acestea două, există o clasă, care este Array Blocking Queue, care este utilizată pentru a implementa interfața Queue.
• Există două tipuri de cozi, cozi nelimitate și cozi delimitate. Cozile care fac parte din pachetul java.util sunt cunoscute sub numele de cozi nelimitate, iar cozile delimitate sunt cozile prezente în pachetul java.util.concurrent.
• Deque sau (coadă cu două capete) este, de asemenea, un tip de coadă care poartă includerea și ștergerea elementelor de la ambele capete.
• Deque-ul este, de asemenea, considerat sigur pentru fire.
• Cozile de blocare sunt, de asemenea, unul dintre tipurile de cozi care sunt, de asemenea, sigure pentru fire. Cozile de blocare sunt folosite pentru a implementa interogările producător-consum.
• Cozile de blocare nu acceptă elemente nule. În cozile de blocare, dacă se încearcă vreo lucrare similară cu valorile nule, atunci este aruncată și NullPointerException.

Implementarea Cozii

Clasele utilizate în implementarea Queue

Clasele care sunt utilizate pentru implementarea funcționalităților cozii sunt date după cum urmează:

• ArrayDeque
• LinkedList
• PriorityQueue

Interfețe utilizate în implementarea Queue

Interfețele Java sunt, de asemenea, utilizate în implementarea cozii Java. Interfețele care sunt utilizate pentru implementarea funcționalităților cozii sunt prezentate după cum urmează:

• Despre ce
• Coada de blocare
• Blocarea Deque

Metode de clasă de coadă Java

În coada Java, există multe metode care sunt folosite foarte frecvent. Interfața Queue promovează diferite metode, cum ar fi inserarea, ștergerea, vizualizarea, etc. Unele dintre operațiunile cozii Java ridică o excepție, în timp ce unele dintre aceste operațiuni returnează o anumită valoare când programul este finalizat.

Notă - În Java SE 8, nu există modificări efectuate în colecția de coadă Java. Aceste metode care sunt definite în continuare sunt pregătite în versiunile ulterioare ale limbajului de programare Java. De exemplu, Java SE 9.

Mai jos sunt definite diferite metode ale cozii Java:

Implementare Java Queue Array

Implementarea în coadă nu este la fel de simplă ca implementarea unei stive.

Pentru a implementa coada folosind Arrays, mai întâi declarăm o matrice care conține n număr de elemente.

adăugarea la matrice java

Apoi definim următoarele operații care trebuie efectuate în această coadă.

1) coadă: O operațiune de inserare a unui element în coadă este Enqueue (funcția coada Enqueue în program). Pentru a introduce un element la capătul din spate, trebuie mai întâi să verificăm dacă coada este plină. Dacă este plin, atunci nu putem introduce elementul. Dacă din spate

2) Coada: Operația de ștergere a unui element din coadă este Dequeue (funcția coada Decodare din program). În primul rând, verificăm dacă coada este goală. Pentru ca operația de scoatere din coadă să funcționeze, trebuie să existe cel puțin un element în coadă.

3) Față: Această metodă returnează partea din față a cozii.

4) Afișare: Această metodă traversează coada și afișează elementele cozii.

Program Java coadă

Următorul program Java demonstrează implementarea Queue.

int parseint

QueueArrayImplementation.java

 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>

Implementarea listei conectate la coadă Java

Deoarece am implementat structura de date Queue folosind Arrays în programul de mai sus, putem implementa și Queue utilizând Linked List.

Vom implementa aceleași metode de introducere la coadă, scoatere la coadă, în față și afișare în acest program. Diferența este că vom folosi structura de date Linked List în loc de Array.

Programul de mai jos demonstrează implementarea Linked List a Queue în Java.

QueueLLImplementation.java

programare dinamică

 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(); } } 

Ieșire:

 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