Adaptive Container: stack and queue

The standard template library (STL) features containers that adapt others to simulate stack and queue behavior. Such containers that internally use another and present a distinct behavior are called adaptive containers.

Using the STL stack Class

The STL stack is a generic class that allows insertions and removal of elements at the top, and dose not permit any access or inspection of elements at the middle. In that sense, the std::stack is quite similar in behavior to a stack of plates.

Instantiating the Stack

std::stack is defined by some impementations of STL  as  template<class elementType, class Container = deque<Type> > class stack;

The parameter elementType is the type of object that is collected by the stack. The second template parameter Container is the stack’s default underlying container implementation class. std::deque is the default for the stack’s internal data storage, and can be replaced by the vector and the list respectively, when the user explicitly instantiates the stack template class with the appropriate second template parameter.

#include <stack>
#include <vector>

int main ()
{
    using namespace std;

    // A stack of integers
    stack <int> stackIntegers;

    // A stack of doubles
    stack <double> stackDoubles;

    // A stack of doubles contained in a vector
    stack <double, vector <double> > stackDoublesInVector;

    return 0;
}

　　

Stack Member Functions

The stack, which adapts another container such as the deque, list, or vector, implements its functionality by restricting the manner in which elements can be inserted or removed, to supply a behavior that is expected strictly from a stack-like mechanism.

#include <stack>
#include <iostream>

int main ()
{
    using namespace std;

    // A stack of integers
    stack <int> stackIntegers;

    // Push sample values to the top of the stack
    cout << "Pushing numbers {25, 10, -1, 5} into the stack:" << endl;

    // push = insert at top of the container
    stackIntegers.push (25);
    stackIntegers.push (10);
    stackIntegers.push (-1);
    stackIntegers.push (5);
    // So, 25 is at the bottom and 5 is at the top!

    cout << "The stack contains " << stackIntegers.size () << " elements";
    cout << endl;

    // pop = remove the topmost element
    cout << endl << "Popping them one after another..." << endl;

    while (stackIntegers.size () != 0)
    {
        cout << "The element at the top is: " << stackIntegers.top();
        cout << endl << "Removing it from the stack!" << endl;

        // Remove the topmost element
        stackIntegers.pop ();
    }

    if (stackIntegers.empty ())
        cout << endl << "The stack is now empty!";

    return 0;
}

　　

Using the STL queue Class

It is a generic class that allows insertion only at the end and removal of elements only at the front. A queue does not permit any access or inspection of elements at the middle; however, elements at the beginning and the end can be accessed. In a sense, the std::queue is quite similar in behavior to a queue of people at the cashier in a supermarket!

Instantiating the Queue

#include <queue>
#include <list>

int main ()
{
    using namespace std;

    // A queue of integers
    queue <int> qIntegers;

    // A queue of doubles
    queue <double> qDoubles;

    // A queue of doubles stored internally in a list
    queue <double, list <double> > qDoublesInList;

    return 0;
}

　　

Member Functions of a queue

As is the case with the std::stack, the std::queue also bases its implementation on an STL container such as the vector, list, or deque. The queue exposes a few member functions that implement the behavioral characteristics of a queue.

#include <queue>
#include <iostream>

int main ()
{
    using namespace std;

    // A queue of integers
    queue <int> qIntegers;

    cout << "Inserting {10, 5, -1, 20} into the queue" << endl;

    // elements pushed into the queue are inserted at the end
    qIntegers.push (10);
    qIntegers.push (5);
    qIntegers.push (-1);
    qIntegers.push (20);
    // the elements in the queue now are {20, -1, 5, 10} in that order

    cout << "The queue contains " << qIntegers.size ();
    cout << " elements" << endl;
    cout << "Element at the front: " << qIntegers.front() << endl;
    cout << "Element at the back: " << qIntegers.back ();
    cout << endl << endl;

    cout << "Removing them one after another..." << endl;
    while (qIntegers.size () != 0)
    {
        cout << "Deleting element " << qIntegers.front () << endl;

        // Remove the element at the front of the queue
        qIntegers.pop ();
    }

    cout << endl;

    // Test if the queue is empty
    if (qIntegers.empty ())
        cout << "The queue is now empty!";

    return 0;
}

　　

Using the STL Priority Queue

The STL priority_queue is different from the queue in that the element of the highest value (or the value deemed as highest by a binary predicate) is available at the front of the queue, and queue operations are restricted to the front.

Instantiating the priortity_queue Class

std::priority_queue is defined as template<class elementType, class Container = vector<Type>, class Compare = less<typename Container::value_type>

#include <queue>

int main ()
{
    using namespace std;

    // A priority queue of integers sorted using std::less <> (default)
    priority_queue <int> pqIntegers;

    // A priority queue of doubles
    priority_queue <double> pqDoubles;

    // A priority queue of integers sorted using std::greater <>
    priority_queue <int, deque <int>, greater <int> > pqIntegers_Inverse;

    return 0;
}

　　

Member Functions of priority_queue

The member functions front() and back(), available in the queue, are not available in the priority_queue.

#include <queue>
#include <iostream>

int main ()
{
    using namespace std;

    priority_queue <int> pqIntegers;
    cout << "Inserting {10, 5, -1, 20} into the priority_queue" << endl;

    // elements get push-ed into the p-queue
    pqIntegers.push (10);
    pqIntegers.push (5);
    pqIntegers.push (-1);
    pqIntegers.push (20);

    cout << "The queue contains " << pqIntegers.size () << " elements";
    cout << endl;
    cout << "Element at the top: " << pqIntegers.top () << endl << endl;

    while (!pqIntegers.empty ())
    {
        cout << "Deleting the topmost element: " << pqIntegers.top ();
        cout << endl;

        pqIntegers.pop ();
    }

    return 0;
}

　　

The next sample demonstrates the instantiation of a priority_queue with std::greater <int> as the predicate. This predicate results in the queue evaluating the smallest number as the element with greatest value, which is then available at the front of the priority queue.

#include <queue>
#include <iostream>

int main ()
{
    using namespace std;

    // Define a priority_queue object with greater <int> as predicate
    // So, numbers of smaller magnitudes are evaluated as greater in value
    priority_queue <int, vector <int>, greater <int> > pqIntegers;

    cout << "Inserting {10, 5, -1, 20} into the priority queue" << endl;

    // elements get push-ed into the p-queue
    pqIntegers.push (10);
    pqIntegers.push (5);
    pqIntegers.push (-1);
    pqIntegers.push (20);

    cout << "The queue contains " << pqIntegers.size () << " elements";
    cout << endl;
    cout << "Element at the top: " << pqIntegers.top () << endl << endl;

    while (!pqIntegers.empty ())
    {
        cout << "Deleting the topmost element " << pqIntegers.top ();
        cout << endl;

        // delete the number at the 'top'
        pqIntegers.pop ();
    }

    return 0;
}