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:
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
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:
| Módszer | Módszer prototípusa | Leírás |
|---|---|---|
| add hozzá | logikai összeadás(E e) | Hozzáadja az e elemet a sor végéhez (végéhez) anélkül, hogy megsértené a kapacitásra vonatkozó korlátozásokat. Igazat ad vissza, ha sikeres, vagy IllegalStateException értéket, ha a kapacitás kimerült. |
| kandikál | E kukucskál() | Visszaadja a sor fejét (elejét), anélkül, hogy eltávolítaná. |
| elem | E elem() | Ugyanazt a műveletet hajtja végre, mint a peek () metódus. A NoSuchElementException parancsot dobja, ha a sor üres. |
| távolítsa el | E Remove() | Eltávolítja a sor fejét, és visszaküldi. A NoSuchElementException parancsot dobja, ha a sor üres. |
| közvélemény kutatás | E szavazás() | Eltávolítja a sor fejét, és visszaküldi. Ha a sor üres, nullát ad vissza. |
| Ajánlat | logikai ajánlat (E e) | Helyezze be az új e elemet a sorba a kapacitáskorlátozások megsértése nélkül. |
| méret | int size() | A sorban lévő elemek méretét vagy számát adja vissza. |
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. A következő Java program bemutatja a Queue megvalósítását. QueueArrayImplementation.java 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. Az alábbi program bemutatja a Queue Linked List megvalósítását Java nyelven. QueueLLImplementation.java Kimenet: Java sor program
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
'); 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 & 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(); } } </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
mi van a pythonban
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(); } } 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