Push and Pop Operation in Stack in Data Structure

The Last-In-First-Out (LIFO) concept is used by Stacks, a type of linear data structure. The Queue has two endpoints, but the Stack only has one (front and rear). It only has one pointer, top pointer, which points to the stack's topmost member. When an element is added to the stack, it is always added to the top, and it can only be removed from the stack. To put it another way, a stack is a container that allows insertion and deletion from the end known as the stack's top.

LIFO (Last in First Out)

According to this method, the piece that was added last will appear first. As an actual illustration, consider a stack of dishes stacked on top of one another. We may claim that the plate we put last comes out first because the plate we put last is on top and we take the plate at the top.

Due to the possibility of understating inventory value, LIFO is not a reliable indicator of ending inventory value. Due to increasing COGS, LIFO leads to reduced net income (and taxes). However, under LIFO during inflation, there are fewer inventory write-downs. Results from average cost are in the middle of FIFO and LIFO.

Real Life Example of LIFO

Let's say that business A sells 10 widgets. $100 per, the first five widgets were delivered two days ago. The remaining five widgets, which cost $200 apiece, just got here yesterday. The last items received are the first to go out on the market, according to the LIFO technique of inventory management. How much may the accountant put down as a cost even though seven widgets were sold?

Although the income from each widget is the same because of its fixed sales price, the cost of each widget is determined by the inventory method used. The last item received is the first item sold according to the LIFO mechanism. Accordingly, the $200 widgets were the first to sell. Following that, the business sold two more of the $100 widgets. Five widgets are priced at $200 each, and two are priced at $100, for a total cost of $1,200 for the widgets using the LIFO approach. As opposed to FIFO, which sells the $200 widgets last, the $100 widgets are sold first. As a result, the price of the sold widgets, which breaks down to five at $100 and two at $200, will be reported as $900. That's why LIFO generates bigger profits during price-increasing periods.

Because of this, LIFO increases expenses during times of price growth and decreases net revenue, which also lowers taxable income. Similar to this, LIFO reduces expenses and raises net income during periods of declining prices, which also raises taxable revenue.

Stack Vs Array

Stack: A stack is a type of linear data structure whose components may only be added to or removed from the top side of the list. The Last in First out (LIFO) principle governs stacks, meaning that the element put last is the first element to be removed. Push operations and pop operations are the terms used to describe the addition and removal of elements from stacks, respectively. A pointer named top is used in stack to maintain track of the last piece that is currently present in the list.

Array: A group of objects kept in consecutive memory regions is known as an array. The goal is to group objects of the same category for storage. As a result, it is simpler to determine each element's position by simply adding an offset to a base value, or the address in memory where the array's first element is stored (generally denoted by the name of the array).

push()

It stacks up a new item. A stack overflow circumstance is when the stack is completely full.

Algorithm for push():

push()

It stacks up a new item. A stack overflow circumstance is when the stack is completely full.

Algorithm for push():

begin
 if stack is full
    return
 endif
else  
 increment top
 stack[top] assign value
end else
end procedure

pop()

It takes something out of the stack. In the opposite sequence from which they were pushed, the things are popped. The condition is referred to as an underflow if the stack is empty.

Algorithm for pop():

begin
 if stack is empty
    return
 endif
else
 store value of stack[top]
 decrement top
 return value
end else
end procedure

Program to demonstrate push and pop operation in stack in data structure in C

#include <stdio.h>
#include <stdlib.h>
#define SIZE 4
int top = -1, inp_array[SIZE];
void push();
void pop();
void show();
int main()
{
    int choice;
    while (1)
    {
        printf("\nPerform operations on the stack:");
        printf("\n1.Push the element\n2.Pop the element\n3.Show\n4.End");
        printf("\n\nEnter the choice: ");
        scanf("%d", &choice);
        switch (choice)
        {
        case 1:
            push();
            break;
        case 2:
            pop();
            break;
        case 3:
            show();
            break;
        case 4:
            exit(0);
        default:
            printf("\nInvalid choice!!");
        }
    }
}
void push()
{
    int x;
    if (top == SIZE - 1)
    {
        printf("\nOverflow!!");
    }
    else
    {
        printf("\nEnter the element to be added onto the stack: ");
        scanf("%d", &x);
        top = top + 1;
        inp_array[top] = x;
    }
}
void pop()
{
    if (top == -1)
    {
        printf("\nUnderflow!!");
    }
    else
    {
        printf("\nPopped element: %d", inp_array[top]);
        top = top - 1;
    }
}
void show()
{
    if (top == -1)
    {
        printf("\nUnderflow!!");
    }
    else
    {
        printf("\nElements present in the stack: \n");
        for (int i = top; i >= 0; --i)
            printf("%d\n", inp_array[i]);
    }
}

Output

10 pushed into stack
20 pushed into stack
30 pushed into stack
30 Popped from stack
Top element is : 20
Elements present in stack : 20 10
...........................................................
Process executed in 3.22 seconds
Press any key to continue.

Explanation

As we can see in the above example of push and pop operation in c, we pushed 10, 20 and 30. After successfully pushing elements into the stack we pop out 30 from the stack and to check if the element is pop out or not, we checked it by performing top operation on the stack, which found out to be 20.

Next TopicBinary Search Tree Implementation

← prev next →