Stack
A Stack is a linear data structure that follows the LIFO (Last-In-First-Out) principle. Stack
has one end called top. It contains only one pointer top pointer pointing to the topmost element
of the stack. Whenever an element is added in the stack, it is added on the top of the stack, and the
element can be deleted only from the stack. In other words, a stack can be defined as a container
in which insertion and deletion can be done from the one end known as the top of the stack.
Some key points related to stack:
1. It is called as stack because it behaves like a real-world stack, piles of books, etc.
2. A Stack is an abstract data type with a pre-defined capacity, which means that it can store
the elements of a limited size.
3. It is a data structure that follows some order to insert and delete the elements, and that order
can be LIFO or FILO.
Working of Stack
Stack works on the LIFO pattern. As we can observe in the below figure there are five memory
blocks in the stack; therefore, the size of the stack is 5.
Suppose we want to store the elements in a stack and let's assume that stack is empty. We have
taken the stack of size 5 as shown below in which we are pushing the elements one by one until
the stack becomes full.
Since our stack is full as the size of the stack is 5. In the above cases, we can observe that it goes
from the top to the bottom when we were entering the new element in the stack. The stack gets
filled up from the bottom to the top.
When we perform the delete operation on the stack, there is only one way for entry and exit as the
other end is closed. It follows the LIFO pattern, which means that the value entered first will be
removed last. In the above case, the value 5 is entered first, so it will be removed only after the
deletion of all the other elements.
The following are some common operations implemented on the stack:
o push(): When we insert an element in a stack then the operation is known as a push. If the
stack is full then the overflow condition occurs.
o pop(): When we delete an element from the stack, the operation is known as a pop. If the
stack is empty means that no element exists in the stack, this state is known as an underflow
state.
o isEmpty(): It determines whether the stack is empty or not.
o isFull(): It determines whether the stack is full or not.
o peek(): It returns the top element without deleting..
PUSH operation
The steps involved in the PUSH operation is given below:
o Before inserting an element in a stack, we check whether the stack is full.
o If we try to insert the element in a stack, and the stack is full, then the overflow condition
occurs.
o When we initialize a stack, we set the value of top as -1 to check that the stack is empty.
o When the new element is pushed in a stack, first, the value of the top gets incremented,
i.e., top=top+1, and the element will be placed at the new position of the top.
o The elements will be inserted until we reach the max size of the stack.
POP operation
The steps involved in the POP operation is given below:
o Before deleting the element from the stack, we check whether the stack is empty.
o If we try to delete the element from the empty stack, then the underflow condition occurs.
o If the stack is not empty, we first access the element which is pointed by the top
o Once the pop operation is performed, the top is decremented by 1, i.e., top=top-1.
Array Implementation of Stack:
Adding an element onto the stack (push operation)
Adding an element into the top of the stack is referred to as push operation. Push operation involves
following two steps.
1. Increment the variable Top so that it can now refere to the next memory location.
2. Add element at the position of incremented top. This is referred to as adding new element
at the top of the stack.
Implementation of push operation: n is the size of the stack
If (top == n )
printf("\n Overflow");
else
{
top = top +1;
stack[top] = val;}
Deletion of an element from a stack (Pop operation)
if(top == -1)
{
printf("Underflow");
return 0;
}
else
{
return stack[top ];
top=top-1;
}
Applications of Stack:
1. Balancing of symbols
2. String reversal
3. Recursion
4. DFS(Depth First Search)
5. Expression conversion
6. Backtracking
