A [**queue**](https://www.educative.io/answers/what-is-a-queue) is a first-in-first-out (FIFO) data structure. It can be implemented using a [linked list](https://www.educative.io/shoteditor/4844410143506432/preview).

The following are the three main operations that can be performed on a queue:

* **enqueue**: adding an element to the end of the list.

* **dequeue**: popping an item from the head of the list.

* **peeking**: displaying the element at the tail of the list.

#include <iostream>
#include <list>
using namespace std;
// Add an element to the tail of the linked list
void enqueue(int elem, list <int> &Queue){
   Queue.push_back(elem);
}
// Remove an element from the head of the linked list
int dequeue(list <int> &Queue){
  if(!Queue.empty()){
    int temp = Queue.front();
    Queue.pop_front();
    return temp;
  }
}
// Display the element from the tail of the linked list
int peek(list <int> &Queue){
  if(!Queue.empty()){
    return Queue.back();
  }
}
int main() {
  // Declaring a list to be used as a Queue
  list <int> Queue;
  // Enqueue 3
  enqueue(3, Queue);
  // Display element at the tail of the linked list
  cout<<"Element at tail: "<<peek(Queue)<<endl;
  // Enqueue 4
  enqueue(4, Queue);
  // Display element at the tail of the linked list
  cout<<"Element at tail: "<<peek(Queue)<<endl;
  // Enqueue 5
  enqueue(5, Queue);
  // Display element at the tail of the linked list
  cout<<"Element at tail: "<<peek(Queue)<<endl;
  // Dequeue elements
  cout<<"Element dequeued: "<<dequeue(Queue)<<endl;
  cout<<"Element dequeued: "<<dequeue(Queue)<<endl;
  cout<<"Element dequeued: "<<dequeue(Queue)<<endl;
  return 0;
}

# A single node of a singly linked list
class Node:
  # constructor
  def __init__(self, data = None, next = None): 
    self.data = data
    self.next = next
# A Linked List class with a single head node
class LinkedList:
  def __init__(self):  
    self.head = None
  # insert at the tail of the linked list
  def insert(self, data):
    newNode = Node(data)
    if(self.head):
      current = self.head
      while(current.next):
        current = current.next
      current.next = newNode
    else:
      self.head = newNode
  # remove an element from the head of the linked list
  def remove(self):
    temp = self.head 
    if (temp is not None):
      element = temp.data
      self.head = temp.next
      temp = None
      return element
  # dispay an element from the tail of the linked list
  def peek(self):
    if(self.head):
      current = self.head
      while(current.next):
        current = current.next
      return current.data
  # print method for the linked list
  def printLL(self):
    current = self.head
    while(current):
      print(current.data)
      current = current.next

# A queue implemented using a linked list
Queue = LinkedList()
# Enqueue 3
Queue.insert(3)
# Display element at the tail
print("Element at the tail:", Queue.peek())
# Enqueue 4
Queue.insert(4)
# Display element at the tail
print("Element at the tail:", Queue.peek())
# Enqueue 5
Queue.insert(5)
# Display element at the tail
print("Element at the tail:", Queue.peek())
# Dequeue elements
print("Element dequeued:", Queue.remove())
print("Element dequeued:", Queue.remove())
print("Element dequeued:", Queue.remove())

Python3

import java.util.*;
class LL {
  public static void main(String args[]) {
  // creating a Queue implemented as a linkedlist
  LinkedList<Integer> Queue = new LinkedList<Integer>(); 
  // Enqueue 3 
  Queue.add(3); 
  // Display element at the tail of the linked list
  System.out.println("Element at tail: " + Queue.getLast());
  // Enqueue 4
  Queue.add(4); 
  // Display element at the tail of the linked list
  System.out.println("Element at tail: " + Queue.getLast());
  // Enqueue 5
  Queue.add(5);
  // Display element at the tail of the linked list
  System.out.println("Element at tail: " + Queue.getLast());
  // Dequeue elemets
  System.out.println("Element dequeued: " + Queue.removeFirst());
  System.out.println("Element dequeued: " + Queue.removeFirst());
  System.out.println("Element dequeued: " + Queue.removeFirst());
 }    
}

Java

How to implement a queue using a linked list

A queue is a first-in-first-out (FIFO) data structure. It can be implemented using a linked list. The following are the three main operations that can be performed on a queue:   enqueue: adding an element to the end of the list.   dequeue: popping an item from the head of the list.   peeking: displaying the element at the tail of the list.   

How to implement a queue using a linked list

Implementation