A sor egy másikfajta lineáris adatstruktúra, amelyet az elemek tárolására használnak, mint bármely más adatszerkezetet, de meghatározott módon. Leegyszerűsítve azt mondhatjuk, hogy a sor a Java programozási nyelv egyik adatszerkezete, amely azonos típusú elemeket tárol. A sorban lévő összetevők FIFO (First In, First Out) viselkedésben tárolódnak. A sorgyűjteménynek két vége van, azaz elülső és hátsó. A sornak két vége van, elöl és hátul.

A következő ábra tökéletesen leírja a Java sor FIFO (First In, First Out) tulajdonságát.

Amint az előző képen látható, láthatjuk, hogy a sor egy lineáris adatstruktúra két terminállal, azaz a kezdettel (elöl) és a végével (hátul). Az összetevők a várólista hátsó végéből kerülnek be a sorba, a komponensek pedig a sor elülső végéből kerülnek ki.

A Queue egy interfész a Jáva amely a Java.util csomaghoz tartozik. Kibővíti a Gyűjtemény felületét is.

A Java Queue interfész általános ábrázolása az alábbiakban látható:

 public interface Queue extends Collection 

Ahogyan fentebb már kifejtettük, hogy a Queue egy interfész, ezért azt is mondhatjuk, hogy a sor nem példányosítható, mert az interfészek nem példányosíthatók. Ha a felhasználó a Queue interfész funkcióit Java nyelven szeretné megvalósítani, akkor kötelező, hogy legyen néhány szilárd osztály, amelyek megvalósítják a Queue felületet.

A Java programozási nyelvben két különböző osztály használható a Queue interfész megvalósítására. Ezek az osztályok:

• LinkedList
• PriorityQueue

A Java Queue jellemzői

A Java Queue a programozási világ egyik legfontosabb adatstruktúrájának tekinthető. A Java Queue a tulajdonságai miatt vonzó. A Java Queue adatstruktúra jelentős tulajdonságai a következők:

• A Java Queue a FIFO (First In, First Out) módszert követi. Azt jelzi, hogy az elemek a sor végén kerülnek be a sorba, és kikerülnek elől.
• A Java Queue felület megadja a Gyűjtemény felület összes szabályát és folyamatát, például a felvételt, törlést stb.
• A Queue interfész megvalósításához két különböző osztályt használnak. Ezek az osztályok a LinkedList és a PriorityQueue.
• E kettőn kívül van egy osztály, a tömbblokkoló sor, amelyet a Queue interfész megvalósítására használnak.
• Kétféle sor létezik, a határtalan várólisták és a korlátos várólisták. A java.util csomag részét képező Várólisták néven Unbounded queues, a korlátos várólisták pedig a java.util.concurrent csomagban található sorok.
• A Deque vagy (kétvégű várólista) szintén egy olyan sortípus, amely mindkét végéről tartalmazza az elemek felvételét és törlését.
• A deque is cérnabiztosnak számít.
• A blokkoló sorok szintén a szálbiztos várólisták egyike. A blokkoló sorok a gyártó-fogyasztó lekérdezések megvalósítására szolgálnak.
• A blokkoló sorok nem támogatják a null elemeket. A Blocking queues szakaszban, ha null értékekhez hasonló munkát próbálunk ki, akkor a NullPointerException is megjelenik.

A Queue megvalósítása

A Queue megvalósításában használt osztályok

A sor funkcióinak megvalósításához használt osztályok a következők:

npm gyorsítótár törlése

• ArrayDeque
• LinkedList
• PriorityQueue

A Queue megvalósításához használt interfészek

A Java interfészek a Java sor implementációjában is használatosak. A sor funkcióinak megvalósításához használt interfészek a következők:

• Miről
• Blokkolási sor
• Blokkolás Deque

Java Queue Class Methods

A Java sorban számos nagyon gyakran használt módszer található. A Queue interfész különböző módszereket támogat, mint például a beszúrás, törlés, betekintés stb. A Java sor egyes műveletei kivételt jelentenek, míg e műveletek egy része egy adott értéket ad vissza a program befejezésekor.

Megjegyzés – A Java SE 8-ban nem történt változtatás a Java sorgyűjteményben. Az alábbiakban definiált módszereket a Java programozási nyelv következő verzióiban tovább készítjük. Például a Java SE 9.

A Java Queue különböző módszereit az alábbiakban definiáljuk:

Java Queue Array megvalósítás

A sormegvalósítás nem olyan egyszerű, mint a verem megvalósítása.

A sor tömbök használatával való megvalósításához először deklarálunk egy tömböt, amely n számú elemet tartalmaz.

Ezután meghatározzuk a következő műveleteket, amelyeket ebben a sorban kell végrehajtani.

1) Sorba állás: Egy elemnek a sorba való beillesztésének művelete az Enqueue (a programban az Enqueue függvénysor). Egy elem beszúrásához a hátsó végén először ellenőriznünk kell, hogy a sor megtelt-e. Ha tele van, akkor nem tudjuk beilleszteni az elemet. Ha hátsó

2) Farok: A sorból egy elem törlésének művelete a Dequeue (a programban a Dequeue funkció). Először ellenőrizzük, hogy a sor üres-e. Ahhoz, hogy a dequeue művelet működjön, legalább egy elemnek kell lennie a sorban.

3) Elöl: Ez a metódus a sor elejét adja vissza.

4) Kijelző: Ez a módszer bejárja a sort, és megjeleníti a sor elemeit.

Java sor program

A következő Java program bemutatja a Queue megvalósítását.

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>

Java sorhoz csatolt lista megvalósítása

Mivel a fenti programban a Queue adatstruktúrát tömbök segítségével valósítottuk meg, így a Queue-t a Linked List segítségével is megvalósíthatjuk.

Ebben a programban ugyanazokat az enqueue, dequeue, front és display módszereket fogjuk megvalósítani. A különbség az, hogy a tömb helyett a Linked List adatstruktúrát fogjuk használni.

mi van a pythonban

Az alábbi program bemutatja a Queue Linked List megvalósítását Java nyelven.

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

Kimenet:

 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