## What will we cover in this tutorial?

We will cover what a Queue is. A Queue is a data structure used by computers. It resembles a queue as we know it.

The key things a Queue should have are efficient operations for insertion (enqueue) and removal (dequeue) of the queue. In this tutorial we will understand what a is, how to represent it, and how to implement the efficient operations.

## Step 1: Understand a Queue

A Queue is like a queue in real life.

A Queue is used in computer science in many scenarios. One scenario is when a resource is shared among multiple consumers, then a Queue is set in front.

This resembles the real world, where we use queues in the grocery store, pharmacy, you name it. In all stores, where we have more consumers than registers (the resource) to serve.

A Queue serves the principle, First-in-first-out or FIFO.

A simple diagram shows the operations of a Queue.

The above queue shows the direction of the Queue and the order they have been added symbolized with the numbers 1 to 8, where 8 is about to be added.

The operations on the Queue are as follows.

• enqueue Adds an element to the back of the Queue.
• dequeue Removes the element of the front of the Queue.

Normally, a Queue would also have a function is_empty, which checks whether the Queue is empty.

## Step 2: How to represent a Queue item with an element

How do you represent the above items of the Queue?

Well, we need to be able to keep an order of the Queue. Let’s try to draw it and see what we can figure out.

Surprised? Well, the Queue goest from left to right, while the arrows between the items go from right to left.

Actually, the items of the Queue can be represented by a simple Node class.

```class Node:
def __init__(self, element=None, next_node=None):
self.element = element
self.next_node = next_node
```

This simple Node class has an element and the pointer to next_node. Hence, the next_node are the arrows in the diagram above. And the element are representing the numbers in the above diagram. Obviously, the element can contain anything.

## Step 3: Create a Queue class to represent the enqueue and dequeue operations

Let’s start in the simple. Given the Nodes, we need a class Queue with a head and tail to implement the operations enqueue and dequeue

The above suggest that if we have head and tail pointer, we can have what we need to implement a Queue data structure.

The enqueue function has the special case where the Queue is empty, otherwise it will do as follows.

• enqueue Create a new Node with the element. Point tails next_node at created Node. Then update tail to point at created Node.

Here we can implement it as follows.

```class Queue:
def __init__(self):
self.tail = None

def enqueue(self, element):
else:
node = Node(element)
self.tail.next_node = node
self.tail = node
```

The dequeue is a bit more involved.

• dequeue Get the element from the Node that head points at. If head Node and tail Node is the same (that is if it is the last Node in the Queue), then point tail and head at None. Otherwise, set the head to point at the the next_node head points at.
```class Queue:
def __init__(self):
self.tail = None

def enqueue(self, element):
else:
node = Node(element)
self.tail.next_node = node
self.tail = node

def dequeue(self):
else:
return element
```

Notice that the dequeue does fail if the Queue is empty. This is dealt with by creating a is_empty function, which returns whether the Queue is empty.

```class Queue:
def __init__(self):
self.tail = None

def enqueue(self, element):
else:
node = Node(element)
self.tail.next_node = node
self.tail = node

def dequeue(self):
else:
return element

def is_empty(self):
```

That is it.

## The full code including a string representation to enable it to be printed

See the full code below. It also contains the __str__(…) function, witch enables it to be printed. Also, how to use it.

```class Queue:
def __init__(self):
self.tail = None

def enqueue(self, element):
else:
node = Node(element)
self.tail.next_node = node
self.tail = node

def dequeue(self):
else:
return element

def is_empty(self):

def __str__(self):
return None
result = "["
while node is not None:
result += str(node.element) + " "
node = node.next_node
return result[:-1] + "]"

q = Queue()
for i in range(10):
q.enqueue(i)
while not q.is_empty():
print(q.dequeue(), '', end='')
```

The above code will result in the following output.

```[0 1 2 3 4 5 6 7 8 9]
0 1 2 3 4 5 6 7 8 9
```

## How to profile a program in Python

In this video we will see how cProfile (default Python library) can help you to get run-times from your Python program.

## Queue vs Python lists

In this video we will compare the performance of a simple Queue implemented directly into Python (no optimisations) with the default Python list.

Can it compare with it on performance?

This is where time complexity analysis come into the picture. A Queue insert and deletion is O(1) time complexity. A Python list used as a queue has O(n) time complexity.

But does the performance and run-time show the same? Here we compare the run-time by using cProfile in Python.

Check out my Course on Linked Lists, Stacks and Queues

## How to Implement a Queue in Python and Compare Performance with a Python list

• What is a Queue?
• Implement a Queue in Python
• Make performance testing of it
• Compare it with performance of a Python list

## What is a Queue?

We all know what a queue is. You go to the grocery store and get spinach, strawberry and bananas for your shake. Then you see a long line of people in front of the register. That line is a queue.

The same holds in programming. You create queues to process data or input of any kind.

## How to implement a Queue in Python

It is easier than you think.

First you create a Node class to represent each node in a queue. A node is an abstraction to represent a point to the next node and the actual element.

```class Node:
def __init__(self, element=None, next_node=None):
self.element = element
self.next_node = next_node

```

Then you create the class for the Queue.

```class Queue:
def __init__(self):
self.tail = None

def enqueue(self, element):
else:
n = Node(element, self.tail)
self.tail.next_node = n
self.tail = n

def dequeue(self):
else:
return element

def is_empty(self):
```

How does it work. Let’s make a simple example.

```q = Queue()
for i in range(10):
q.enqueue(i)

while not q.is_empty():
print(q.dequeue())
```

Which will output.

```0
1
2
3
4
5
6
7
8
9
```

Yes! You guessed it.

## How do we test performance?

I like to use the cProfile library. It is easy to use and gives informative results.

So how do you test performance? You simply import the cProfile library and use the cProfile.run(…) call.

You also need to do some operations to see how your Queue performs. See the code as an example.

```import cProfile

def profile_queue(n):
q = Queue()
for i in range(n):
q.enqueue(i)
while not q.is_empty():
q.dequeue()

def profile(n):
profile_queue(n)

cProfile.run("profile(100000)")

```

Which will result in the following output.

```   Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
1    0.000    0.000    0.819    0.819 <string>:1(<module>)
100000    0.310    0.000    0.351    0.000 Queue.py:11(enqueue)
100000    0.308    0.000    0.308    0.000 Queue.py:19(dequeue)
100000    0.041    0.000    0.041    0.000 Queue.py:2(__init__)
100001    0.021    0.000    0.021    0.000 Queue.py:27(is_empty)
1    0.132    0.132    0.819    0.819 Queue.py:34(profile_queue)
1    0.000    0.000    0.819    0.819 Queue.py:42(profile)
1    0.000    0.000    0.000    0.000 Queue.py:7(__init__)
1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
1    0.008    0.008    0.008    0.008 {range}

```

The interesting line is line 9, which tells us how much time is spend in the call to profile_queue.

But is the result good?

We need to compare it to other implementations.

## Performance testing the Queue with a Python list

Python lists are used for anything. Can we use a Python list as a Queue. Of course. Let’s try to implement that and compare it to our Queue.

```import cProfile

def profile_queue(n):
q = Queue()
for i in range(n):
q.enqueue(i)
while not q.is_empty():
q.dequeue()

def profile_list_as_queue(n):
q = []
for i in range(n):
q.insert(0,i)
while len(q) > 0:
q.pop()

def profile(n):
profile_queue(n)
profile_list_as_queue(n)

cProfile.run("profile(100000)")
```

How does that compare? Let’s see.

```   Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
1    0.000    0.000    3.680    3.680 <string>:1(<module>)
100000    0.295    0.000    0.331    0.000 Queue.py:11(enqueue)
100000    0.298    0.000    0.298    0.000 Queue.py:19(dequeue)
100000    0.036    0.000    0.036    0.000 Queue.py:2(__init__)
100001    0.019    0.000    0.019    0.000 Queue.py:27(is_empty)
1    0.104    0.104    0.756    0.756 Queue.py:34(profile_queue)
1    0.101    0.101    2.924    2.924 Queue.py:42(profile_list_as_queue)
1    0.000    0.000    3.680    3.680 Queue.py:50(profile)
1    0.000    0.000    0.000    0.000 Queue.py:7(__init__)
100001    0.005    0.000    0.005    0.000 {len}
1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
100000    2.805    0.000    2.805    0.000 {method 'insert' of 'list' objects}
100000    0.012    0.000    0.012    0.000 {method 'pop' of 'list' objects}
2    0.004    0.002    0.004    0.002 {range}

```

Wow. Our Queue is way faster than the Python list.

But how is it comparing in general? Comparing the performance of the Queue and a Python list as a Queue.

While it is difficult to see, the performance of the Queue is O(n) (linear) while the performance of the Python list as a Queue is O(n^2).

Hence, the Queue will outperform the Python list for this use case.