# Relational Operators for comparing Queue in C++ STL

Reading time: 30 minutes | Coding time: 10 minutes

In this article, we will take a look at different relational operators for Queue container in C++ STL. This enables a programmer to compare queue directly. Some of the relational operators are:

`==`

`!=`

`<`

`<=`

`>`

`>=`

Queue is a linear data structure that implements FIFO(First In First Out).Queue comes under Sequence container adpaters of C++ container library.

Relational Operators used with queue c++ STL are overloaded operators which are used to perform appropriate comparisons between two queue objects. The queues are compared element by element.

Read about Operator Overloading in C++Relational Operators for Queue are -

## (1) ==

```
bool operator== (const queue<T,Container>& queue1,const queue<T,Container>& queue2);
```

It returns true if queue 1 is identical to queue 2, otherwise false.

The queue gets compared element by element. First the element 1 queue 1 gets compared to element 1 of queue 2 , Then element 2 of queue 1 gets compared to element 2 of queue 2 and so on. If all the elements are found to be same and length of both queues is equal then true is returned , Otherwise false.

### Example 1.1

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
if (q1 == q2)/*q1 and q2 contains same elements and queues are of same length. Hence q1 == q2 returns true*/
cout << "\n q1 and q2 are same";
else
cout<<"\nq1 and q2 are different";
return 0;
}
```

Output:

### Example 1.2

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(2); //pushing 1 into q2 ,Now q2= 1
if (q1 == q2)//q1 and q2 contains different elements.Hence q1 == q2 returns false
cout << "\n q1 and q2 are same";
else
cout<<"\nq1 and q2 are different";
return 0;
}
```

Output

## (2) !=

```
bool operator!= (const queue<T,Container>& queue1,const queue<T,Container>& queue2);
```

It returns true if queue 1 is not identical to queue 2, otherwise false.

The queue gets compared element by element. First the element 1 queue 1 gets compared to element 1 of queue 2 , Then element 2 of queue 1 gets compared to element 2 of queue 2 and so on. If any element is found to be not equal then true is returned , Otherwise false.

### Example 2.1

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
q2.push(2); //pushing 2 into q2 ,Now q2= 1 2
if (q1 != q2)//q1 and q2 contains different elements.Hence q1 != q2 returns true
cout << "\n q1 and q2 are not same";
else
cout<<"\nq1 and q2 are same";
return 0;
}
```

Output

### Example 2.2

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
q2.push(2); //pushing 2 into q2 ,Now q2= 1 2
q1.push(2); //pushing 2 into q1 ,Now q1= 1 2
if (q1 != q2)//q1 and q2 contains same elements.Hence q1 != q2 returns false
cout << "\n q1 and q2 are not same";
else
cout<<"\nq1 and q2 are same";
return 0;
}
```

Output

## (3) <

```
bool operator< (const queue<T,Container>& queue1,const queue<T,Container>& queue2);
```

It returns true if queue 1 is less than queue 2, otherwise false.

The queue gets compared element by element. First the element 1 queue 1 gets compared to element 1 of queue 2 , Then element 2 of queue 1 gets compared to element 2 of queue 2 and so on. If all the elements of queue 1 are found to be less than elements of queue 2 then true is returned , Otherwise false.

### Example 3

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
q1.push(2); //pushing 2 into q2 ,Now q1= 1 2
q2.push(3); //pushing 3 into q1 ,Now q2= 1 3
if (q1 < q2)//q2 has element greater than q1.Hence q1 < q2 returns true
cout << "\n q1 is less than q2";
else
cout<<"\nq1 is greater than q2";
return 0;
}
```

Output

## (4) <=

```
bool operator<= (const queue<T,Container>& Queue1,const queue<T,Container>& Queue2);
```

It returns true if queue 1 is less than or equal to queue 2, otherwise false.

The queue gets compared element by element. First the element 1 queue 1 gets compared to element 1 of queue 2 , Then element 2 of queue 1 gets compared to element 2 of queue 2 and so on. If all the elements of queue 1 are found to be less than or equal to elements of queue 2 then true is returned , Otherwise false.

### Example 4

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
q1.push(2); //pushing 2 into q2 ,Now q1= 1 2
q2.push(3); //pushing 3 into q1 ,Now q2= 1 3
if (q1 <= q2)//q2 has element greater than q1.Hence q1 < q2 returns true
cout << "\n q1 is less than equal to q2";
else
cout<<"\nq1 is greater than q2";
return 0;
}
```

Output

## (5) >

```
bool operator> (const queue<T,Container>& Queue1,const queue<T,Container>& Queue2);
```

It returns true if queue 1 is greater than queue 2, otherwise false.

The queue gets compared element by element. First the element 1 queue 1 gets compared to element 1 of queue 2 , Then element 2 of queue 1 gets compared to element 2 of queue 2 and so on. If all the elements of queue 1 are found to be greater than elements of queue 2 then true is returned , Otherwise false.

### Example 5

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
q1.push(5); //pushing 2 into q2 ,Now q1= 1 5
q2.push(4); //pushing 3 into q1 ,Now q2= 1 4
if (q1 > q2)//q1 has element greater than q2.Hence q1 > q2 returns true
cout << "\n q1 is greater than q2";
else
cout<<"\nq1 is less than q2";
return 0;
}
```

Output

## (6) >=

```
bool operator>= (const queue<T,Container>& Queue1,const queue<T,Container>& Queue2);
```

It returns true if queue 1 is greater than or equal to queue 1, otherwise false.

The queue gets compared element by element. First the element 1 queue 1 gets compared to element 1 of queue 2 , Then element 2 of queue 1 gets compared to element 2 of queue 2 and so on. If all the elements of queue 1 are found to be greater than or equal to elements of queue 2 then true is returned , Otherwise false.

### Example 4

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(1); //pushing 1 into q1 ,Now q1= 1
q2.push(1); //pushing 1 into q2 ,Now q2= 1
q1.push(2); //pushing 2 into q2 ,Now q1= 1 2
q2.push(3); //pushing 3 into q1 ,Now q2= 1 3
if (q1 <= q2)//q2 has element greater than q1.Hence q1 < q2 returns true
cout << "\n q1 is less than equal to q2";
else
cout<<"\nq1 is greater than q2";
return 0;
}
```

Output

All above relational operators return True if the condition holds, and False otherwise.

The time complexity of all above relational operators are O(N).

### Working

The two queues are compared by comparing their values pairwise, starting at the beginning, with each comparison looking at two values in corresponding positions, until a determination of the appropriate relationship between the two queues can be made.

### Code Example

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2; //creating two queue objects
cout<<"Relational Operators for Queue";
for(int i=1;i<=5;i++)
{
q1.push(i); //pushing values (1-5) into queue 1
q2.push(i); //pushing values (1-5) into queue 2
}
if (q1 == q2) //returns true as both the queues contain same elements
cout << "\nq1 and q2 are same";
q1.push(6); //pushing value 6 into queue 1
q2.push(20);
/*Now queue 1 is 1 2 3 4 5 6 and queue 2 is 1 2 3 4 5 20
making queue 1 less than queue 2*/
if (q1 != q2)
cout << "\nq1 and q2 are not same";
if(q1 < q2)
cout<<"\nq1 is less than q2";
if(q1 <= q2)
cout<<"\nq1 is less than equal to q2";
if(q1 > q2)
cout<<"\nq1 is greater than q2";
if(q1 >= q2)
cout<<"\nq1 is greater than equal to q2";
return 0;
}
```

Output

### Applications

- Relational Operators for queue helps us compare elements of queue.
- It makes it easier for us programmers to do so as we don't have to write the same set of code to perform relational operations in every queue based projects.

## Question

Consider the following C++ code:

```
#include <iostream>
#include <queue>
using namespace std;
int main()
{
queue<int> q1, q2;
q1.push(0);
q2.push(NULL);
if (q1 == q2)
cout << "\n q1 and q2 are same";
return 0;
}
```