LIFO (LastInFirstOut) approach in Programming (original) (raw)

LIFO (Last-In-First-Out) approach in Programming

Last Updated : 11 Jul, 2025

Prerequisites - FIFO (First-In-First-Out) approach in Programming, FIFO vs LIFO approach in Programming
LIFO is an abbreviation for last in, first out. It is a method for handling data structures where the first element is processed last and the last element is processed first.

Real-life example:

In this example, following things are to be considered:

This is known as Last-In-First-Out approach or LIFO.

Where is LIFO used:

  1. Data Structures:
    Certain data structures like Stacks and other variants of Stacks use LIFO approach for processing data.
  2. Extracting latest information:
    Sometimes computers use LIFO when data is extracted from an array or data buffer. When it is required to get the most recent information entered, the LIFO approach is used.

Program Examples for LIFO:

Implementation: Using Stack data structure.

C++ `

// C++ program to demonstrate // working of LIFO // using stack in C++ #include<bits/stdc++.h> using namespace std;

// Pushing element on the top of the stack stack stack_push(stack stack) { for (int i = 0; i < 5; i++) { stack.push(i); } return stack; }

// Popping element from the top of the stack stack stack_pop(stack stack) { cout << "Pop :"; 

for (int i = 0; i < 5; i++) 
{ 
    int y = (int)stack.top();
    stack.pop();
    cout << (y) << endl; 
} 
return stack;

}

// Displaying element on the top of the stack void stack_peek(stack stack) { int element = (int)stack.top(); cout << "Element on stack top : " << element << endl; }

// Searching element in the stack void stack_search(stack stack, int element) { int pos = -1,co = 0; while(stack.size() > 0) { co++; if(stack.top() == element) { pos = co; break; } stack.pop(); }

if (pos == -1) 
    cout << "Element not found" << endl; 
else
    cout << "Element is found at position " << pos << endl;

}

// Driver code int main() { stack stack ; 

stack = stack_push(stack); 
stack = stack_pop(stack); 
stack = stack_push(stack); 
stack_peek(stack); 
stack_search(stack, 2); 
stack_search(stack, 6); 
return 0;

}

// This code is contributed by Arnab Kundu

Java

// Java program to demonstrate // working of LIFO // using Stack in Java

import java.io.; import java.util.;

class GFG { // Pushing element on the top of the stack static void stack_push(Stack stack) { for (int i = 0; i < 5; i++) { stack.push(i); } }

// Popping element from the top of the stack
static void stack_pop(Stack<Integer> stack)
{
    System.out.println("Pop :");

    for (int i = 0; i < 5; i++) {
        Integer y = (Integer)stack.pop();
        System.out.println(y);
    }
}

// Displaying element on the top of the stack
static void stack_peek(Stack<Integer> stack)
{
    Integer element = (Integer)stack.peek();
    System.out.println("Element on stack top : " + element);
}

// Searching element in the stack
static void stack_search(Stack<Integer> stack, int element)
{
    Integer pos = (Integer)stack.search(element);

    if (pos == -1)
        System.out.println("Element not found");
    else
        System.out.println("Element is found at position " + pos);
}

public static void main(String[] args)
{
    Stack<Integer> stack = new Stack<Integer>();

    stack_push(stack);
    stack_pop(stack);
    stack_push(stack);
    stack_peek(stack);
    stack_search(stack, 2);
    stack_search(stack, 6);
}

}

Python3

Python3 program to demonstrate working of LIFO

Pushing element on the top of the stack

def stack_push(stack): for i in range(5): stack.append(i) return stack

Popping element from the top of the stack

def stack_pop(stack): print("Pop :")

for i in range(5):
    y = stack[-1]
    stack.pop()
    print(y)
return stack

Displaying element on the top of the stack

def stack_peek(stack): element = stack[-1] print("Element on stack top :", element)

Searching element in the stack

def stack_search(stack, element): pos = -1 co = 0 while(len(stack) > 0): co+=1 if(stack[-1] == element): pos = co break stack.pop()

if (pos == -1):
    print( "Element not found")
else:
    print("Element is found at position", pos)

stack = [] stack_push(stack) stack_pop(stack) stack_push(stack) stack_peek(stack) stack_search(stack, 2) stack_search(stack, 6)

This code is contributed by rameshtravel07.

C#

// C# program to demonstrate // working of LIFO // using Stack in C# using System; using System.Collections.Generic;

class GFG { // Pushing element on the top of the stack static void stack_push(Stack stack) { for (int i = 0; i < 5; i++) { stack.Push(i); } } 

// Popping element from the top of the stack 
static void stack_pop(Stack<int> stack) 
{ 
    Console.WriteLine("Pop :"); 

    for (int i = 0; i < 5; i++)
    { 
        int y = (int)stack.Pop(); 
        Console.WriteLine(y); 
    } 
} 

// Displaying element on the top of the stack 
static void stack_peek(Stack<int> stack) 
{ 
    int element = (int)stack.Peek(); 
    Console.WriteLine("Element on stack top : " + element); 
} 

// Searching element in the stack 
static void stack_search(Stack<int> stack, int element) 
{ 
    bool pos = stack.Contains(element); 

    if (pos == false) 
        Console.WriteLine("Element not found"); 
    else
        Console.WriteLine("Element is found at position " + pos); 
} 

// Driver code
public static void Main(String[] args) 
{ 
    Stack<int> stack = new Stack<int>(); 

    stack_push(stack); 
    stack_pop(stack); 
    stack_push(stack); 
    stack_peek(stack); 
    stack_search(stack, 2); 
    stack_search(stack, 6); 
}

}

// This code contributed by Rajput-Ji

JavaScript

`

Output

Pop :4 3 2 1 0 Element on stack top : 4 Element is found at position 3 Element not found

Complexity Analysis: