What Do You Mean by LIFO Data Structure?


Larry Thompson

When it comes to understanding data structures, one commonly encountered term is LIFO. LIFO stands for Last In, First Out, and it is a popular data structure that follows a specific ordering principle. In this article, we will explore what LIFO data structure entails and how it can be implemented in various programming languages.

What is LIFO Data Structure?

LIFO data structure, as the name suggests, follows the principle of “Last In, First Out.” This means that the last element added to the data structure will be the first one to be removed.

LIFO can be visualized as a stack of objects or a stack of plates. When you add a new object or plate to the stack, it goes on top of the previous ones. And when you need to remove an object or plate, you start from the top and work your way down.

Let’s understand this with an example:

  • Step 1: You have an empty stack.
  • Step 2: You add object A to the stack.
  • Step 3: You add object B to the stack.
  • Step 4: You add object C to the stack.

Your stack now looks like this (with C being at the top):

  • C
  • B
  • A

If you want to remove an object from the stack using LIFO principles:

  • Step 1: You remove object C from the top of the stack.
  • Step 2: You remove object B from the top of the stack.
  • Step 3: You remove object A from the top of the stack.

As a result, the stack becomes empty again.

Implementing LIFO Data Structure

LIFO data structure can be implemented in multiple programming languages using different approaches. One common way to implement LIFO is by using an array or a linked list.

LIFO with Arrays

In languages like C++, Java, or Python, you can use arrays to create a LIFO data structure. By utilizing the built-in methods for adding and removing elements from an array, you can easily achieve the Last In, First Out behavior. Here’s an example in Python:

# Create an empty stack
stack = []

# Add elements to the stack

# Remove elements from the stack
top_element = stack.pop()
print(top_element)  # Output: C

top_element = stack.pop()
print(top_element)  # Output: B

top_element = stack.pop()
print(top_element)  # Output: A

LIFO with Linked Lists

In other programming languages like C or JavaScript, where dynamic data structures are more commonly used, you can implement LIFO using linked lists. Linked lists consist of nodes that link to each other and store both data and references to other nodes.

To create a LIFO data structure with linked lists, you will need to keep track of the head node (the last element added) and update it every time a new element is added. Here’s an example in JavaScript:

// Node class
class Node {
constructor(data) {
this.data = data;
this.next = null;

// Stack class
class Stack {
constructor() {
this.head = null;

// Add element to the stack
push(data) {
const newNode = new Node(data);
newNode.next = this.head;
this.head = newNode;

// Remove element from the stack
pop() {
if (this.head === null) return null;

const topElement = this.head.data;
this.head = this.next;

return topElement;

// Create a new stack
const stack = new Stack();

// Add elements to the stack

// Remove elements from the stack
let topElement = stack.pop();
console.log(topElement); // Output: C

topElement = stack.log(topElement); // Output: B

topElement = stack.log(topElement); // Output: A


LIFO data structure, also known as Last In, First Out, is a fundamental concept in computer science. It follows the principle of adding elements to the top and removing them from the top, making it efficient for certain applications.

In this article, we explored what LIFO data structure means and how it can be implemented using arrays or linked lists in various programming languages. By understanding LIFO, you can expand your knowledge of different data structures and their applications.

So next time you encounter LIFO in your programming journey, remember that it's all about what comes last goes first!