Algorithm

  1. Initialize Queue:

    • Create a class for the Queue.
    • Declare instance variables: maxSize, queueArray[], front, rear, size.

  2. Enqueue (Insert):

    • Check for overflow.
    • Increment rear.
    • Set queueArray[rear] to the new element.
    • Increment size.

  3. Dequeue (Remove):

    • Check for underflow.
    • Get the element at the front (queueArray[front]).
    • Increment front.
    • Decrement size.

  4. Front (Peek):

    • Return queueArray[front].

  5. Check if Queue is Empty:

    • Return (size == 0).

  6. Check if Queue is Full:

    • Return (size == maxSize).

These steps provide a high-level algorithm for the basic operations of a queue data structure in Java.

 

Code Examples

#1 Code Example- Java program to implement Stack

Code - Java Programming

public class Queue {
  int SIZE = 5;
  int items[] = new int[SIZE];
  int front, rear;

  Queue() {
    front = -1;
    rear = -1;
  }

  // check if the queue is full
  boolean isFull() {
    if (front == 0 && rear == SIZE - 1) {
      return true;
    }
    return false;
  }

  // check if the queue is empty
  boolean isEmpty() {
    if (front == -1)
      return true;
    else
      return false;
  }

  // insert elements to the queue
  void enQueue(int element) {

    // if queue is full
    if (isFull()) {
      System.out.println("Queue is full");
    }
    else {
      if (front == -1) {
        // mark front denote first element of queue
        front = 0;
      }

      rear++;
      // insert element at the rear
      items[rear] = element;
      System.out.println("Insert " + element);
    }
  }

  // delete element from the queue
  int deQueue() {
    int element;

    // if queue is empty
    if (isEmpty()) {
      System.out.println("Queue is empty");
      return (-1);
    }
    else {
      // remove element from the front of queue
      element = items[front];

      // if the queue has only one element
      if (front >= rear) {
        front = -1;
        rear = -1;
      }
      else {
        // mark next element as the front
        front++;
      }
      System.out.println( element + " Deleted");
      return (element);
    }
  }

  // display element of the queue
  void display() {
    int i;
    if (isEmpty()) {
      System.out.println("Empty Queue");
    }
    else {
      // display the front of the queue
      System.out.println("\nFront index-> " + front);

      // display element of the queue
      System.out.println("Items -> ");
      for (i = front; i  < = rear; i++)
        System.out.print(items[i] + "  ");

      // display the rear of the queue
      System.out.println("\nRear index-> " + rear);
    }
  }

  public static void main(String[] args) {

    // create an object of Queue class
    Queue q = new Queue();

    // try to delete element from the queue
    // currently queue is empty
    // so deletion is not possible
    q.deQueue();

    // insert elements to the queue
    for(int i = 1; i  <  6; i ++) {
      q.enQueue(i);
    }

    // 6th element can't be added to queue because queue is full
    q.enQueue(6);

    q.display();

    // deQueue removes element entered first i.e. 1
    q.deQueue();

    // Now we have just 4 elements
    q.display();

  }
}
Copy The Code & Try With Live Editor

Output

x
–
+
cmd
Queue is empty
Insert 1
Insert 2
Insert 3
Insert 4
Insert 5
Queue is full
Front index-> 0
Items ->
1 2 3 4 5
Rear index-> 4
1 Deleted
Front index-> 1
Items ->
2 3 4 5
Rear index-> 4

#2 Code Example- Implement stack using Queue interface

Code - Java Programming

import java.util.Queue;
import java.util.LinkedList;

class Main {

  public static void main(String[] args) {
    // Creating Queue using the LinkedList class
    Queue < Integer> numbers = new LinkedList<>();

    // enqueue
    // insert element at the rear of the queue
    numbers.offer(1);
    numbers.offer(2);
    numbers.offer(3);
    System.out.println("Queue: " + numbers);

    // dequeue
    // delete element from the front of the queue
    int removedNumber = numbers.poll();
    System.out.println("Removed Element: " + removedNumber);

    System.out.println("Queue after deletion: " + numbers);
    }
}
Copy The Code & Try With Live Editor

Output

x
–
+
cmd
Queue: [1, 2, 3]
Removed Element: 1
Queue after deletion: [2, 3]
Advertisements

Demonstration

Java Programing Example to Implement the queue data structure-DevsEnv