Stack functions in C++:

Stack: A stack is a linear data structure in the C++ programming language that follows the Last-In-First-Out (LIFO) principle. The final element added is the first one deleted. Therefore, it is effectively a collection of elements. Stacks, which resemble an actual stack or pile, like a stack of plates, are frequently used for transferring data.

Stacks may be worked with in C++ utilizing the Standard Template Library (STL), which offers a functional and efficient stack container class. This class offers methods and functions for confirming whether the stack is empty, deleting items from the top of the stack, and more. Stacks are helpful for many tasks, including parsing expressions, keeping track of function calls in a program, and resolving issues involving data management that call for a last-in, first-out strategy.

A stack of dishes serves as a practical illustration of a stack. When a waiter or waitress brings a stack of clean dishes to your table at a restaurant, picture what it will be like. They add each additional plate to the stack as they continue to serve your table. You or your fellow diners pull the top dish off the stack once you've finished eating. You start taking out plates, starting with the last one added to the stack. The stack remains full once this procedure is completed, with all the plates having been consumed.

A stack data structure can be compared to this real-world example in several ways:

Last-In-First-Out (LIFO): The plate that was added to the stack most recently is the first one to be used. This behavior can be compared to the operation of a stack data structure in computer science.

Push and Pop: Placing a plate on top of a stack suggests a "push" action, whereas removing a dish from a stack resembles a "pop" action.

No Access to Middle Plates: Just as you can only access the top element of a stack electronically, you can only access or delete the top plate without impacting the plates below it.

Stack function in C++:

An adaptable container implements the stack data structure, called a "stack", in the C++ standard library. The last component added to a stack is the first one deleted since stacks are final-in-first-out (LIFO) data structures. The Standard Template Library (STL) includes the C++ stack container as part of its <stack> header. We must include the library in order to utilize it.

Declaration and Initialization of a Stack: You must first include the "stack" header in order to utilize a stack in C++. Using the std::stack template, a stack may be declared and initialized.

For instance:

#include<iostream>
#include<stack>
int main() {
   
std:: stack<int> myStack; // Declares an empty integer stack
   
return 0;
}

Pushing Elements into the Stack: Elements may be added to the stack by using the push() function to move them to the top. "Pushing" into the stack is another term for this activity.

Example:

std:: stack<int> myStack;
myStack.push(42); // Pushes the value 42 onto the stack

Popping Elements from the Stack: The pop() method may be used to pop the top element out of the stack and retrieve it. The top element is indeed removed, but no value is returned.

For instance:

std:: stack<int> myStack;
myStack.push(42);
myStack.pop(); // Removes the top element (42) from the stack

Accessing the Top Element:

You may access the top element of the stack without removing it by using the top() function. By doing so, you may inspect the element without modifying the stack's contents.

For example:

std:: stack<int> myStack;
myStack.push(42);
int topElement = myStack.top(); // Retrieves the top element (42) without removing it

Checking Stack Size and Empty Status:

The size() method returns the amount of components in the stack, even with the empty() function produces a boolean indicating if the stack is empty or not.

For instance:

std:: stack<int> myStack;
bool isEmpty = myStack.empty(); // Returns true because the stack is empty
myStack.push(42);
int stackSize = myStack.size(); //Returns 1, as there is one element in the stack

Clearing the Stack: Using an empty stack and the swap() method of the std::stack library, you may remove every element from the stack.

For instance:

std:: stack<int> myStack;
myStack.push(42);
myStack.push(17);
myStack = std:: stack<int>(); // Clears all elements from the stack

Types of Implementations of Stack in C++:

Stacks may be built in C++ using a variety of data structures, each with advantages and disadvantages of its own. Here are a few common stack implementation types:

Array-Based Stack: An array-based stack stores its items in a fixed-size array. It uses an index or pointer to keep track of the top element. The top index is increased when an element is placed into the stack and decremented when an element is popped. If the maximum stack size is known in advance, this method is straightforward and effective. It has size restrictions, though, and resizing may be difficult and expensive.

Linked List-Based Stack: The contents of the stack are kept in a single or double-linked list in this implementation. Each list node represents a different element, and the head of the list is equivalent to the top of the stack. While popping removes the head node, pushing an element involves building a new node and updating the head. Due to the dynamic size of linked list-based stacks, items can be added or deleted without paying attention to the restrictions of a fixed-size array. This method works well in circumstances when the stack size fluctuates, although the pointers add a little extra memory burden.

STL Stack Container: The C++ Standard Library includes the std::stack abstract data type, which is implemented using a variety of underlying containers, such as vectors or deques. This stack container makes it simple to utilize by abstracting the underlying data structure. Developers may concentrate on stack operations like push, pop, and top without having to concern themselves with the specifics of implementation. This method works well for most applications because it gives you a simple user interface and lets you pick the best underlying data structure based on your requirements.

Vector-Based Stack: A vector-based stack, like an array-based stack, stores elements in a dynamic container such as std::vector. The final element is removed by popping after elements are pushed to the end of the vector. This method offers dynamic sizing, enabling the stack to change size as necessary. It offers a compromise between efficiency and dynamic size by combining some of the benefits of both arrays and linked lists.

Deque-Based Stack: A Deque (double-ended queue) is another container that may be used to construct a stack. Deques make effective insertion and removal possible from both ends. Depending on your needs, you may regard the top of the stack as being at the front or the rear of the deque. Dynamic sizing, effective insertions and deletions, and flexible usage are all features of deque-based stacks.

The unique needs of your application determine the implementation of your stack. An array-based stack can be suitable if you want a straightforward stack with a specified maximum size. Linked lists, vector-based stacks, or deque-based stacks are more suitable for changing scaling and effective insertions and removals. For many C++ applications, the STL's std::stack provides a practical and flexible choice by abstracting the implementation's inner workings for user-friendliness.

Example code by using Array-based stack:

#include<iostream>
using namespace std;
#define MAX 1000 // Maximum size for the stack
class MyStack {
  
int top;
public:
  
int stackArray[MAX]; // Stack array

  
MyStack() { top = -1; }
  
bool push(int x);
  
int pop();
  
bool isEmpty();
};
// Pushes an element onto the stack
bool MyStack::push(int item) {
   
if (top >= (MAX-1)) {
       
cout << "Stack Overflow!!!" << endl;
       
return false;
    }
   
else {
       
stackArray[++top] = item;
       
cout << item << endl;
       
return true;
    }
}
// Removes or pops elements from the stack
int MyStack::pop() {
   
if (top < 0) {
       
cout << "Stack Underflow!!" << endl;
       
return 0;
    }
   
else {
       
int item = stackArray[top--];
       
return item;
    }
}

// Checks if the stack is empty
bool MyStack::isEmpty() {
   
return (top < 0);
}
// Main program to demonstrate stack functions
int main() {
   
MyStack stack;
   
cout << "Pushing onto the stack:" << endl;
   
stack.push(2);
   
stack.push(4);
   
stack.push(6);
   
cout << "Popping from the stack:" << endl;
   
while (!stack.isEmpty()) {
       
cout << stack.pop() << endl;
    }
   
return 0;
}

Output:

Explanation:

A stack data structure is created and used in this example of C++ code using a specially created class called MyStack. The Last-In-First-Out (LIFO) principle, which states that the last element added to the stack is the first one withdrawing, is applied to stacks in this context.

The behavior of the stack is managed by the MyStack class. Top and stackArray are two essential characteristics that it keeps. Initially set to -1 to denote an empty stack, the top reflects the index of the top element in the stack. The stack's items are stored in the integer array stackArray, which has a maximum storage capacity set by the MAX constant.

Push, pop, and isEmpty are the three main stack operations provided by the code. Element addition to the top of the stack is possible using the push operation. By comparing the current value of the top to the maximum capacity, it determines whether the stack has reached capacity. It outputs "Stack Overflow!!!" and returns false if the stack is full. If not, it advances the top to the following accessible position and adds the supplied element to the stackArray. As each pushed piece is added to the stack, it is shown.

On the other hand, the pop operation makes it easier to remove pieces from the stack's top. By looking at the top value it determines whether the stack is empty. It writes "Stack Underflow!!!" and returns 0 as an error value if the stack is empty. If not, it pulls the element from the top place in the stackArray, moves the top down to point to the next element, and then returns the value it found. This procedure shows how elements are removed from the stack until it is empty and is carried out within a loop in the main function.

Example code for a stack using Linked List:

#include<iostream>
using namespace std;

// Define a structure for a node in the stack
struct StackNode {
    int data;
    struct StackNode* next;
};
// Initialize the top of the stack as NULL
struct StackNode* top = NULL;
//function to push an element onto the stack
void push(int newValue) {
    // Create a new node
    struct StackNode* newNode = new StackNode;
    newNode->data = newValue;
    // Set the new node's next pointer to the current top of the stack
    newNode->next = top;
    // Update the top of the stack to the new node
    top = newNode;
}
//function to pop an element from the stack
void pop() {
    if (top == NULL)
        cout << "Stack Underflow" << endl;
    else {
        cout << "The popped element is " << top->data << endl;

        // Move the top pointer to the next element in the stack
        top = top->next;
    }
}
//function to display the elements in the stack
void display() {
    struct StackNode* currentNode;
    if (top == NULL)
        cout << "Stack is empty" << endl;
    else {
        currentNode = top;
        cout << "Stack elements are: ";
        while (currentNode != NULL) {
            cout << currentNode->data << " ";
            currentNode = currentNode->next;
        }
    }
    cout << endl;
}
int main() {
    int choice, newValue;
    cout << "1) Push element onto the stack" << endl;
    cout << "2) Pop element from the stack" << endl;
    cout << "3) Display stack elements" << endl;
    cout << "4) Exit" << endl;
    do {
        cout << "Enter your choice: ";
        cin >> choice;
        switch (choice) {
        case 1: {
            cout << "Enter the value to be pushed onto the stack: ";
            cin >> newValue;
            push(newValue);
            break;
        }
        case 2: {
            pop();
            break;
        }
        case 3: {
            display();
            break;
        }
        case 4: {
            cout << "Exiting the program" << endl;
            break;
        }
        default: {
            cout << "Invalid Choice" << endl;
        }
        }
    } while (choice != 4);
    return 0;
}

Output:

Explanation:

Stack Implementation: The code begins by establishing the StackNode structure, which represents a node in the linked list-based stack. Each node has a reference to the following node (struct StackNode* next) and an integer data value (int data).

Initializing the Stack: An empty stack is denoted by the top of the stack being initialized as NULL. In order to make sure it is available across the entire program, this is done outside of any functions.

Pushing Elements Into the Stack: The push function adds an integer value (newValue) to the stack from an input value of an integer. The new node is created, its data field is filled with the input value, and its next pointer is set to the top of the current stack. Finally, it updates the stack's top to include the new node and adds it to the stack.

Pop Function: Removing Top Element from Stack: The pop function eliminates the top element from the stack. The value of the popped element is shown, and the top pointer is updated to point to the following element in the stack if the stack is not empty (top is not NULL). By doing this, the top piece is effectively removed.

The display function displays the components that are now present in the stack. As it loops over the stack, starting at the top, it displays the value of each element. If the stack is empty, it is clear that it is empty.

Until the user chooses to depart (choice!= 4), the menu is repeatedly shown to them by the program using a do-while loop. Depending on the user's selection, the proper function (push, pop, or show) is called, changing or displaying the stack as necessary.

Example code for a stack using STL stack container:

#include<iostream>
#include<stack>
#include<string>
#include<cstdlib>
using namespace std;
int main() {
   stack<int> customStack; // Create an integer stack named customStack
   int choice, element; // Variables to store user choice and element
   while (true) {
      cout << "Select an operation:" << endl;
      cout << "1. Check Stack Size" << endl;
      cout << "2. Push element onto the Stack" << endl;
      cout << "3. Pop Element from the Stack" << endl;
      cout << "4. View Top Element of the Stack" << endl;
      cout << "5. Exit" << endl;
      cout << "Enter your choice: ";
      cin >> choice; // Prompt the user for their choice
      switch(choice) {
         Case 1:
            cout << "Stack size: ";
            cout << customStack.size() << endl; // Display the size of the stack
         break;
         Case 2:
            cout << "Enter an integer to push onto the stack: ";
            cin >> element;
            customStack.push(element); // Push the entered value onto the stack
         break;
         Case 3:
            if (!customStack.empty()) {
               element = customStack.top();
               customStack.pop(); // Pop and remove the top element from the stack
               cout << "Popped element: " << element << endl;
            } else {
               cout << "Stack is Empty" << endl;
            }
         break;
         case 4:
            if (!customStack.empty()) {
               cout << "Top Element of the Stack: ";
               cout << customStack.top() << endl; // Display the top element of the stack
            } else {
               cout << "Stack is Empty" << endl;
            }
         break;
         case 5:
            exit(0); // Exit the program
         break;
         Default:
            cout << "Invalid Choice" << endl; // Handle invalid user input
      }
   }

   return 0;
}

Output:

Explanation:

The Standard Template Library (STL) stack container is used to implement a stack in this C++ code. Through a normal menu, the program enables the user to carry out numerous stack operations.

The code begins by including the required C++ libraries, such as stack for building a stack data structure and iostream for input and output operations. Additionally, it contains the libraries for handling strings and ending programs, cstdlib, and string, respectively.

A stack with the name "customStack" and an integer type is declared inside the main method. Integer elements will be stored and managed in this stack. The user's menu selection and the integer element that will be added to the stack will be stored in two variables, "choice" and "element," respectively.

The while(true) construct is used to ensure that the program enters an endless loop and stays there until the user expressly tells it to stop. The user is given a menu of stack actions inside the loop, each of which is supported by a number option.

Application of Stack:

1. Infix to Postfix Expression:

In computer science and programming, stacks are often used to convert infix expressions to postfix expressions. Because operators are inserted between operands in infix expressions, it can be difficult for computers to evaluate them effectively. The evaluation procedure is made simpler by converting these words to postfix, sometimes referred to as Reverse Polish Notation (RPN). Stacks are important to this conversion. Operators are added to the stack during conversion and are popped off the stack and added to the output when a higher precedence operator is encountered, ensuring proper evaluation order.

The resultant postfix expression is a preferred format in many applications, including calculators, compilers, and spreadsheet software, where effective expression evaluation is crucial. It may be quickly evaluated using a stack or other data structures.

2. Expression Parsing/Evaluation

Stacks are frequently used in programming languages like C++ and others for expression parsing and evaluation. In order to make infix expressions-those having operators between operands, such as "3 + 5"-into postfix or prefix forms, which are simpler to evaluate, a stack is utilized in expression parsing. The stack is essential for handling operators and operands during evaluation, depending on their precedence and associativity. It makes sure that expressions are accurately evaluated in accordance with mathematical norms. When users enter equations in infix notation into calculator programs, spreadsheet applications, and mathematical computing tools, this application is crucial because the stack-driven parsing and evaluation procedure provides accurate outcomes.

3. Tree Traversals

Tree traversals, such as in-order, pre-order, and post-order, are basic strategies for visiting and processing data in tree structures, particularly binary trees. In binary search trees (BSTs), which are frequently employed for data storage and retrieval, tree traversals are used extensively. The components in a BST are visited in ascending order during an in-order traversal, which is beneficial for tasks like finding the smallest or biggest element in a dataset. Because they ensure that the parent nodes are dealt with before their offspring, pre-order traversals are useful for making copies of trees. Child nodes are released before their parent nodes in post-order traversals, which are frequently employed in memory management and resource deallocation. Beyond BSTs, tree traversals are a vital tool for effectively working with hierarchical data and are essential to many algorithms and data structures, from expression parsing to hierarchical data processing.

4. Sorting Algorithms:

Computer science sorting algorithms are vital and have several uses in a variety of fields. They are used to arrange data in a certain order, which enables efficient data retrieval, search, and analysis. Sorting plays a key role in databases and information retrieval, among other areas, in order to maximize search operations. In order to find patterns and trends in data, sorting is essential in data preparation for data mining and machine learning activities. Sorting is a technique used in software development to manage lists of things in graphical user interfaces, improve search engines, and guarantee effective data storage and retrieval. Additionally, computational geometry and algorithmic problem-solving both depend on sorting.

5. Towers Of Hanoi:

Mathematicians and computer scientists have been fascinated by the Towers of Hanoi puzzle for many years. It uses three rods and a series of discs that are first placed on one rod in decreasing size order. One disc at a time can be moved, and a larger disc must never be stacked on top of a smaller one. The goal is to transfer the complete stack to another rod while following the restrictions. This game's seeming simplicity hides significant implications for algorithm development and computer science. The issue may be divided into smaller, identical subproblems, making it a great example for teaching and understanding recursion. The Towers of Hanoi likewise highlight the need for effective algorithmic design since it takes careful calculation and optimization to arrive at the best solution for a higher number of discs. It is used practically to optimize disc storage and data transportation in computing systems and serves as a fundamental problem in the study of algorithms.

Conclusion:

In conclusion, stack functions in C++ offer a basic data structure for Last-In, First-Out (LIFO) data management. They are a fundamental tool in programming because they are necessary for several applications, such as function call management, parsing expressions, and resolving challenging issues like the Towers of Hanoi.

Next TopicThread Synchronization in C++

← prev next →