TechCodeview

Rinda ir cita veida lineāra datu struktūra, ko izmanto elementu glabāšanai tāpat kā jebkura cita datu struktūra, bet noteiktā veidā. Vienkāršiem vārdiem sakot, mēs varam teikt, ka rinda ir datu struktūras veids Java programmēšanas valodā, kurā tiek glabāti tāda paša veida elementi. Rindā esošie komponenti tiek saglabāti FIFO (First In, First Out) darbībā. Rindas kolekcijai ir divi gali, t.i., priekšējais un aizmugurējais. Rindai ir divi gali, kas ir priekšā un aizmugurē.

10 ml līdz oz

Šis attēls lieliski apraksta Java rindas rekvizītu FIFO (First In, First Out).

Kā paskaidrots iepriekšējā attēlā, mēs redzam, ka rinda ir lineāra datu struktūra ar diviem termināliem, t.i., sākumu (priekšpusē) un beigām (aizmugurē). Komponenti tiek pievienoti rindai no rindas aizmugures, un komponenti tiek iegūti no rindas priekšējā gala.

Rinda ir interfeiss Java kas pieder Java.util pakotnei . Tas arī paplašina kolekcijas saskarni.

Java rindas interfeisa vispārīgais attēlojums ir parādīts zemāk:

 public interface Queue extends Collection 

Kā minēts iepriekš, rinda ir interfeiss, tāpēc mēs varam arī teikt, ka rindu nevar izveidot, jo saskarnes nevar izveidot. Ja lietotājs vēlas ieviest rindas interfeisa funkcionalitāti Java valodā, tad obligāti ir jābūt dažām cietajām klasēm, kas ievieš rindas interfeisu.

Java programmēšanas valodā ir divas dažādas klases, kas tiek izmantotas rindas interfeisa ieviešanai. Šīs klases ir:

• LinkedList
• PriorityQueue

Java rindas raksturojums

Java rindu var uzskatīt par vienu no svarīgākajām datu struktūrām programmēšanas pasaulē. Java rinda ir pievilcīga savu īpašību dēļ. Java rindas datu struktūras nozīmīgākās īpašības ir norādītas šādi:

• Java rinda pakļaujas FIFO (First In, First Out) metodei. Tas norāda, ka elementi tiek ievadīti rindā beigās un izslēgti no priekšpuses.
• Java rindas saskarne nodrošina visus kolekcijas interfeisa noteikumus un procesus, piemēram, iekļaušanu, dzēšanu utt.
• Rindas interfeisa ieviešanai tiek izmantotas divas dažādas klases. Šīs klases ir LinkedList un PriorityQueue.
• Izņemot šos divus, ir arī klase, kas ir masīvu bloķēšanas rinda, kas tiek izmantota rindas interfeisa ieviešanai.
• Ir divu veidu rindas: neierobežotās rindas un ierobežotās rindas. Rindas, kas ir pakotnes java.util daļa, ir zināmas kā neierobežotās rindas, un ierobežotās rindas ir rindas, kas atrodas pakotnē java.util.concurrent.
• Deque vai (divgalu rinda) ir arī rindas veids, kas ietver elementu iekļaušanu un dzēšanu no abiem galiem.
• Deque arī tiek uzskatīts par pavedienu drošu.
• Bloķēšanas rindas ir arī viens no rindu veidiem, kas ir arī drošas pavedieniem. Bloķēšanas rindas tiek izmantotas, lai ieviestu ražotāja un patērētāja vaicājumus.
• Bloķēšanas rindas neatbalsta nulles elementus. Ja sadaļā Bloķēšanas rindas tiek izmēģināts kāds darbs, kas līdzīgs nulles vērtībām, tiek izmests arī NullPointerException.

Rindas ieviešana

Rindas ieviešanā izmantotās klases

Klases, kas tiek izmantotas rindas funkcionalitātes ieviešanai, ir norādītas šādi:

• ArrayDeque
• LinkedList
• PriorityQueue

Rindas ieviešanā izmantotās saskarnes

Java saskarnes tiek izmantotas arī Java rindas ieviešanā. Saskarnes, kas tiek izmantotas rindas funkcionalitātes ieviešanai, ir norādītas šādi:

• Par ko
• Bloķēšanas rinda
• Bloķēšana Deque

Java rindas klases metodes

Java rindā ir daudzas metodes, kas tiek izmantotas ļoti bieži. Rindas interfeiss veicina dažādas metodes, piemēram, ievietošanu, dzēšanu, apskati utt. Dažas Java rindas darbības rada izņēmumu, savukārt dažas no šīm darbībām atgriež noteiktu vērtību, kad programma ir pabeigta.

javascript druka

Piezīme. Programmā Java SE 8 Java rindu kolekcijā nav veiktas nekādas izmaiņas. Šīs definētās metodes tālāk tiek sagatavotas turpmākajās Java programmēšanas valodas versijās. Piemēram, Java SE 9.

Tālāk ir definētas dažādas Java rindas metodes:

Java rindas masīva ieviešana

Rindas ieviešana nav tik vienkārša kā steka ieviešana.

Lai ieviestu rindu, izmantojot masīvus, mēs vispirms deklarējam masīvu, kurā ir n elementu skaits.

Pēc tam mēs definējam šādas darbības, kas jāveic šajā rindā.

1) Rinda: Darbība elementa ievietošanai rindā ir Enqueue (funkcija rinda Enqueue programmā). Lai ievietotu elementu aizmugurē, vispirms ir jāpārbauda, ​​vai rinda ir pilna. Ja tas ir pilns, mēs nevaram ievietot elementu. Ja aizmugurē

2) Aste: Darbība elementa dzēšanai no rindas ir Dequeue (funkcija rinda Dequeue programmā). Pirmkārt, mēs pārbaudām, vai rinda ir tukša. Lai rindas darbība darbotos, rindā ir jābūt vismaz vienam elementam.

vesels skaitlis līdz virknei

3) Priekšpuse: Šī metode atgriež rindas priekšpusi.

4) Displejs: Šī metode šķērso rindu un parāda rindas elementus.

Java rindas programma

Nākamā Java programma parāda rindas ieviešanu.

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 rindas saistīto sarakstu ieviešana

Tā kā iepriekš minētajā programmā esam ieviesuši rindas datu struktūru, izmantojot masīvus, mēs varam ieviest arī rindu, izmantojot saistīto sarakstu.

Šajā programmā mēs ieviesīsim tās pašas rindas, rindas, priekšējās un displeja metodes. Atšķirība ir tāda, ka mēs izmantosim saistīto sarakstu datu struktūru, nevis masīvu.

10 no 40

Tālāk redzamā programma parāda rindas saistīto sarakstu ieviešanu 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(); } } 

Izvade:

 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