The Royal Coding
Binary Search Bubble Sort Build A Max Heap Build A Min Heap Graph Traversal Heap Sort Implementing A Basic Hash Table Implementing A Binary Search Tree Implementing A Queue Implementing A Stack Insertion Sort Length Of Linked List Linear Search Linked Lists Merge A Two Sorted Linked List Merge Sort Quick Sort Redix Sort Reverse A Linked List Selection Sort Ternary Search Suffix Automata Construction

Python/C/C++/JAVA

Advanced Practice Programs with Code and Concept

By D.S

Implementing a Queue

Okay so basically in this program, you're gonna get asked to input two whole numbers. It's not that hard, don't worry - just type in any two numbers you want. After you've done that, the program is gonna automatically add them up and store the answer for ya. Pretty cool, huh? So if you wanna try it out just go ahead and give it a shot! And hey, who knows - maybe this will be your first step towards becoming a programming whizz kid or something.

(a.) C Code

#include <stdio.h>
#define SIZE 5

void enQueue(int);
void deQueue();
void display();

int items[SIZE], front = -1, rear = -1;

int main() {
  //deQueue is not possible on empty queue
  deQueue();

  //enQueue 5 elements
  enQueue(1);
  enQueue(2);
  enQueue(3);
  enQueue(4);
  enQueue(5);

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

  display();

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

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

  return 0;
}

void enQueue(int value) {
  if (rear == SIZE - 1)
    printf("Queue is Full!!");
  else {
    if (front == -1)
      front = 0;
    rear++;
    items[rear] = value;
    printf("Inserted -> %d", value);
  }
}

void deQueue() {
  if (front == -1)
    printf("Queue is Empty!!");
  else {
    printf("Deleted : %d", items[front]);
    front++;
    if (front > rear)
      front = rear = -1;
  }
}

// Function to print the queue
void display() {
  if (rear == -1)
    printf("Queue is Empty!!!");
  else {
    int i;
    printf("Queue elements are:");
    for (i = front; i <= rear; i++)
      printf("%d  ", items[i]);
  }
  printf("\n");
}
Output:-
[1, 2, 3, 4, 5]
After removing an element
[2, 3, 4, 5]

(b.) C++ Code

#include <iostream>
#define SIZE 5
using namespace std;

class Queue {
 private:
  int items[SIZE], front, rear;

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

  bool isFull() {
    return (front == 0 && rear == SIZE - 1);
  }

  bool isEmpty() {
    return (front == -1);
  }

  void enQueue(int element) {
    if (isFull()) {
      cout << "Queue is full";
    } else {
      if (front == -1) front = 0;
      rear++;
      items[rear] = element;
      cout << endl << "Inserted " << element << endl;
    }
  }

  int deQueue() {
    int element;
    if (isEmpty()) {
      cout << "Queue is empty" << endl;
      return (-1);
    } else {
      element = items[front];
      if (front >= rear) {
        front = -1;
        rear = -1;
      } else {
        front++;
      }
      cout << endl << "Deleted -> " << element << endl;
      return (element);
    }
  }

  void display() {
    if (isEmpty()) {
      cout << endl << "Empty Queue" << endl;
    } else {
      cout << endl << "Front index-> " << front;
      cout << endl << "Items -> ";
      for (int i = front; i <= rear; i++)
        cout << items[i] << "  ";
      cout << endl << "Rear index-> " << rear << endl;
    }
  }
};

int main() {
  Queue q;

  q.deQueue();  // deQueue is not possible on empty queue

  // enQueue 5 elements
  q.enQueue(1);
  q.enQueue(2);
  q.enQueue(3);
  q.enQueue(4);
  q.enQueue(5);

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

  q.display();

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

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

  return 0;
}
Output:-
[1, 2, 3, 4, 5]
After removing an element
[2, 3, 4, 5]

(c.) Python Code

# Queue implementation in Python
class Queue:
    def __init__(self):
        self.queue = []
  
    # Add an element
    def enqueue(self, item):
        self.queue.append(item)
  
    # Remove an element
    def dequeue(self):
        if len(self.queue) < 1:
            return None
        return self.queue.pop(0)
  
    # Display the queue
    def display(self):
        print(self.queue)
  
    def size(self):
        return len(self.queue)

# These lines should NOT be indented
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)

q.display()

q.dequeue()

print("After removing an element")
q.display()
Output:-
[1, 2, 3, 4, 5]
After removing an element
[2, 3, 4, 5]

(d.) Java Code

public class Queue {
        int SIZE = 5;
        int items[] = new int[SIZE];
        int front, rear;
      
        Queue() {
          front = -1;
          rear = -1;
        }
      
        boolean isFull() {
          if (front == 0 && rear == SIZE - 1) {
            return true;
          }
          return false;
        }
      
        boolean isEmpty() {
          if (front == -1)
            return true;
          else
            return false;
        }
      
        void enQueue(int element) {
          if (isFull()) {
            System.out.println("Queue is full");
          } else {
            if (front == -1)
              front = 0;
            rear++;
            items[rear] = element;
            System.out.println("Inserted " + element);
          }
        }
      
        int deQueue() {
          int element;
          if (isEmpty()) {
            System.out.println("Queue is empty");
            return (-1);
          } else {
            element = items[front];
            if (front >= rear) {
              front = -1;
              rear = -1;
            } /* Q has only one element, so we reset the queue after deleting it. */
            else {
              front++;
            }
            System.out.println("Deleted -> " + element);
            return (element);
          }
        }
      
        void display() {
          /* Function to display elements of Queue */
          int i;
          if (isEmpty()) {
            System.out.println("Empty Queue");
          } else {
            System.out.println("Front index-> " + front);
            System.out.println("Items -> ");
            for (i = front; i <= rear; i++)
              System.out.print(items[i] + "  ");
      
            System.out.println("Rear index-> " + rear);
          }
        }
      
        public static void main(String[] args) {
          Queue q = new Queue();
      
          // deQueue is not possible on empty queue
          q.deQueue();
      
          // enQueue 5 elements
          q.enQueue(1);
          q.enQueue(2);
          q.enQueue(3);
          q.enQueue(4);
          q.enQueue(5);
      
          // 6th element can't be added to because the 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();
      
        }
      }
Output:-
[1, 2, 3, 4, 5]
After removing an element
[2, 3, 4, 5]

How did you feel about this post?

😍 🙂 😐 😕 😡

Was this helpful?

👍 👎