תור הוא סוג אחר של מבנה נתונים ליניארי המשמש לאחסון אלמנטים בדיוק כמו כל מבנה נתונים אחר אבל בצורה מסוימת. במילים פשוטות, אנו יכולים לומר שהתור הוא סוג של מבנה נתונים בשפת התכנות ג'אווה המאחסן אלמנטים מאותו סוג. הרכיבים בתור מאוחסנים בהתנהגות FIFO (כניסה ראשונה, יוצאת ראשונה). ישנם שני קצוות באוסף התור, כלומר, מלפנים ומאחור. לתור יש שני קצוות שהם מלפנים ומאחור.

האיור הבא מתאר בצורה מושלמת את המאפיין FIFO (כניסה ראשונה, יוצאת ראשונה) של תור Java.

כפי שהוסבר בתמונה הקודמת, אנו יכולים לראות שהתור הוא מבנה נתונים ליניארי עם שני מסופים, כלומר התחלה (קדמי) וסוף (אחורי). רכיבים מתווספים בתוך התור מהקצה האחורי של התור והרכיבים נשלפים מהקצה הקדמי של התור.

התור הוא ממשק ב- Java ששייך לחבילת Java.util. זה גם מרחיב את ממשק האוסף.

הייצוג הגנרי של ממשק Java Queue מוצג להלן:

 public interface Queue extends Collection 

כפי שדיברנו לעיל שהתור הוא ממשק, לכן אנחנו יכולים גם לומר שלא ניתן ליצור את התור כי לא ניתן ליצור ממשקים. אם משתמש רוצה ליישם את הפונקציונליות של ממשק Queue ב-Java, חובה להחזיק כמה מחלקות סולידיות שמיישמות את ממשק Queue.

מיון מהיר

בשפת התכנות Java, ישנן שתי מחלקות שונות המשמשות ליישום ממשק ה-Queue. שיעורים אלו הם:

• רשימה מקושרת
• PriorityQueue

מאפיינים של תור Java

תור Java יכול להיחשב כאחד ממבני הנתונים החשובים ביותר בעולם התכנות. Java Queue אטרקטיבי בגלל המאפיינים שלו. המאפיינים המשמעותיים של מבנה הנתונים של Java Queue ניתנים כדלקמן:

• Java Queue מציית לאופן FIFO (ראשון נכנס, ראשון יוצא). זה מציין שאלמנטים מוכנסים לתור בסוף ומבוטלים מלפנים.
• ממשק Java Queue נותן את כל הכללים והתהליכים של ממשק האוסף כמו הכללה, מחיקה וכו'.
• ישנן שתי מחלקות שונות המשמשות ליישום ממשק ה-Queue. מחלקות אלו הן LinkedList ו-PriorityQueue.
• מלבד שני אלה, יש מחלקה כלומר, Array Blocking Queue המשמשת ליישום ממשק Queue.
• ישנם שני סוגים של תורים, תורים ללא גבולות ותורים מוגבלים. התורים שהם חלק מחבילת java.util ידועים בתור Unbounded queues ותורים מוגבלים הם התורים הקיימים בחבילה java.util.concurrent.
• ה-Deque or (תור בעל קצוות כפול) הוא גם סוג של תור הנושא הכלה ומחיקה של אלמנטים משני הקצוות.
• הדסק נחשב גם בטוח לחוט.
• חסימת תורים הם גם אחד מסוגי התורים שהם גם בטוחים לשרשור. תורי החסימה משמשים ליישום שאילתות יצרן-צרכן.
• תורי חסימה אינם תומכים ברכיבי null. בתורי חסימה, אם נוסתה עבודה הדומה לערכי null, אזי נזרקת גם NullPointerException.

יישום תור

שיעורים המשמשים ביישום תור

המחלקות המשמשות ליישום הפונקציונליות של התור ניתנות באופן הבא:

• ArrayDeque
• רשימה מקושרת
• PriorityQueue

ממשקים המשמשים ביישום תור

ממשקי Java משמשים גם ביישום תור Java. הממשקים המשמשים ליישום הפונקציונליות של התור ניתנים כדלקמן:

• לגבי מה
• תור חסימה
• חסימת Deque

שיטות כיתה ב-Java Queue

בתור Java, ישנן שיטות רבות בשימוש נפוץ מאוד. ממשק ה-Queue מקדם שיטות שונות כמו הוספה, מחיקה, הצצה וכו'. חלק מהפעולות של תור Java מעלות חריג בעוד שחלק מהפעולות הללו מחזירות ערך מסוים כאשר התוכנית הושלמה.

הערה - ב-Java SE 8, לא בוצעו שינויים באוסף התורים של Java. שיטות אלו המוגדרות תחת מוכנות בהמשך בגרסאות העוקבות של שפת התכנות Java. לדוגמה, Java SE 9.

שיטות שונות של תור Java מוגדרות להלן:

יישום מערך תורים של Java

יישום תור אינו פשוט כמו יישום מחסנית.

כדי ליישם תור באמצעות מערכים, אנו מכריזים תחילה על מערך שמכיל n מספר אלמנטים.

לאחר מכן אנו מגדירים את הפעולות הבאות שיבוצעו בתור זה.

שינוי שם הספרייה בלינוקס

1) תור: פעולה להכנסת אלמנט לתור היא Enqueue (תור פונקציות Enqueue בתוכנית). כדי להכניס אלמנט בקצה האחורי, עלינו לבדוק תחילה אם התור מלא. אם הוא מלא, אז אנחנו לא יכולים להכניס את האלמנט. אם אחורי

2) זנב: הפעולה למחיקת אלמנט מהתור היא Dequeue (תור פונקציות Dequeue בתוכנית). ראשית, אנו בודקים אם התור ריק. כדי שתפעול תור תעבוד, חייב להיות לפחות אלמנט אחד בתור.

3) קדמי: שיטה זו מחזירה את חזית התור.

מספרים רומאים 1 עד 100

4) תצוגה: שיטה זו חוצה את התור ומציגה את רכיבי התור.

תוכנית Java Queue

תוכנית Java הבאה מדגימה את היישום של Queue.

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 Queue

מכיוון שהטמענו את מבנה הנתונים Queue באמצעות Arrays בתוכנית לעיל, נוכל ליישם את ה-Queue באמצעות Linked List.

אנו ניישם את אותן שיטות תור, מיקום, חזית ותצוגה בתוכנית זו. ההבדל הוא שאנו נשתמש במבנה הנתונים של Linked List במקום ב-Array.

התוכנית שלהלן מדגימה את יישום הרשימה המקושרת של Queue ב-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(); } } 

תְפוּקָה:

 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