Sort a stack using a temporary stack

Introduction

Stacks are fundamental data structures widely used in computer science and programming. They follow the Last-In-First-Out (LIFO) principle, meaning that the most recently added element is the first to be removed. While stacks are efficient for various operations, sorting elements within a stack can be challenging. However, there is an elegant and efficient solution: sorting a stack using a temporary stack.

Understanding the Problem

Sorting a stack involves arranging its elements in ascending or descending order, while maintaining the LIFO property. This can be challenging because stacks do not support random access, making traditional sorting algorithms like quicksort or mergesort less straightforward to apply. Stacks support two primary operations:

Push: To add an element to the top of the stack.
Pop: To remove and return the element from the top of the stack.

Why Use a Temporary Stack?

A stack follows the Last-In-First-Out (LIFO) principle, meaning that the element added last will be removed first. To sort a stack in ascending order, we can use a temporary stack to rearrange the elements. The basic idea is to pop elements from the original stack and insert them into the temporary stack in sorted order. Once the temporary stack is sorted, we can push the elements back into the original stack. By repeating this process, we can efficiently sort the stack.

The Temporary Stack Solution

The algorithm for sorting a stack using a temporary stack leverages the concept of two stacks to achieve the desired result. Here's an overview of the process:

Create two stacks: the original stack to be sorted and a temporary stack.
While the original stack is not empty, repeat the following steps:
1. Pop the top element from the original stack and store it in a temporary variable.
2. While the temporary stack is not empty and the top element is greater than the temporary variable, pop elements from the temporary stack and push them onto the original stack.
3. Push the temporary variable onto the temporary stack.
Repeat steps 2a-2c until the original stack is empty. At this point, the temporary stack contains the elements sorted in ascending order.
If you want to sort in descending order, simply reverse the process. Create the temporary stack, but push larger elements from the original stack to the temporary stack instead of smaller ones.

Example

Let's walk through an example to illustrate how the algorithm works:

Original Stack: 4, 2, 7, 1, 3

Temporary Stack: (empty)

1. Pop 4 from the original stack and push it onto the temporary stack:

Original Stack: 2, 7, 1, 3

Temporary Stack: 4

2. Pop 2 from the original stack and push it onto the temporary stack:

Original Stack: 7, 1, 3

Temporary Stack: 4, 2

3. Pop 7 from the original stack and push it onto the temporary stack:

Original Stack: 1, 3

Temporary Stack: 4, 2, 7

4. Pop 1 from the original stack and push it onto the temporary stack:

Original Stack: 3

Temporary Stack: 4, 2, 7, 1

5. Pop 3 from the original stack and push it onto the temporary stack:

Original Stack: (empty)

Temporary Stack: 4, 2, 7, 1, 3

The original stack is empty, and the temporary stack contains the sorted elements: 1, 2, 3, 4, 7.

Implementation:

#include <iostream>
#include <stack>

using namespace std;

void sortStack(stack<int>& originalStack) {
    stack<int> tempStack;

    while (!originalStack.empty()) {
        int temp = originalStack.top();
        originalStack.pop();

        while (!tempStack.empty() && tempStack.top() > temp) {
            originalStack.push(tempStack.top());
            tempStack.pop();
        }

        tempStack.push(temp);
    }

    // Copy the sorted elements back to the original stack
    while (!tempStack.empty()) {
        originalStack.push(tempStack.top());
        tempStack.pop();
    }
}

int main() {
    stack<int> stk;

    // Push elements onto the stack
    stk.push(30);
    stk.push(-5);
    stk.push(18);
    stk.push(14);
    stk.push(-3);

    cout << "Original Stack: ";
    while (!stk.empty()) {
        cout << stk.top() << " ";
        stk.pop();
    }

    // Re-populate the stack
    stk.push(30);
    stk.push(-5);
    stk.push(18);
    stk.push(14);
    stk.push(-3);

    // Sort the stack
    sortStack(stk);

    cout << "\nSorted Stack (Ascending Order): ";
    while (!stk.empty()) {
        cout << stk.top() << " ";
        stk.pop();
    }

    return 0;
}

Explanation:

The primary function in the program is sortStack, which accepts a reference to a stack of integers (stack<int>& originalStack) as input and is responsible for sorting it in ascending order.
Inside the sortStack function, an auxiliary stack called tempStack is declared. This auxiliary stack serves as a temporary container to facilitate the sorting process.
The program enters a while loop, which continues as long as the originalStack is not empty. This loop is the core of the sorting algorithm.
In this loop, It extracts the top element (temp) from the originalStack and removes it from the stack using pop().
Then, it enters another while loop to examine if the tempStack is not empty and if the top element of tempStack is greater than temp.
If this condition holds true, it pops elements from tempStack and pushes them back into the originalStack. This step ensures that the originalStack maintains ascending order with the smallest elements on top.
Subsequently, it pushes the temp element onto the tempStack. This step temporarily stores the sorted elements
After the initial while loop completes, the originalStack is empty, and the tempStack contains the elements sorted in ascending order.
The program proceeds to transfer the sorted elements from the tempStack back into the originalStack. This final step ensures that the sorted elements are correctly placed back into the original stack.
In the main function, a sample stack named stk is created and populated with elements {30, -5, 18, 14, -3}.
The program prints the original stack elements by repeatedly popping and displaying them in a loop.
The original stack stk is then re-populated with the same elements for demonstration purposes.
The sortStack function is called to sort the stack in ascending order.
Finally, the program prints the sorted stack elements, which should now be displayed in ascending order.

Program Output:

Time Complexity:

The time complexity of this algorithm is O(n^2), where "n" is the number of elements in the stack. This is because for each element in the original stack, you potentially perform a series of operations (popping and pushing) on the temporary stack, and in the worst case, you may need to move all the elements from the temporary stack back to the original stack for each element in the original stack.

Space Complexity:

The space complexity of this algorithm is O(n) because you are using an additional temporary stack to store elements. In the worst case, when the original stack is in descending order (requires maximum rearrangement), you would need to store all elements in the temporary stack, which would be "n" elements. Therefore, the space complexity is linear with respect to the number of elements in the stack.

Conclusion:

Sorting a stack using a temporary stack is a compelling algorithmic problem that presents several important concepts and challenges. This approach provides a practical illustration of stack manipulation and highlights the significance of auxiliary data structures in solving complex problems.

By employing a temporary stack, we can systematically reorder the elements from the original stack while maintaining the Last-In-First-Out (LIFO) behavior. The step-by-step algorithm provided ensures that the elements are correctly sorted in the temporary stack, and they can be subsequently pushed back into the original stack to achieve the desired sorting order.

One of the notable aspects of this technique is its relatively high time complexity of O(n^2), where 'n' is the number of elements in the stack. This means that the algorithm's performance can degrade quickly as the size of the stack increases. Consequently, it is not the most efficient sorting algorithm for larger datasets, and more efficient sorting methods like quicksort or mergesort are preferred in practical scenarios.

Sorting a stack using a temporary stack is a fundamental problem that offers valuable insights into data structure manipulation and algorithmic problem-solving. While not suitable for production-level sorting tasks due to its time complexity, it remains a valuable exercise for those looking to enhance their programming skills and deepen their understanding of data structures. It also serves as a stepping stone to more

Next TopicSplit a Circular List into 2 Halves

← prev next →