Last In First Out - LIFO

LIFO stands for Last In, First Out and is a principle of data structure management where the last element added is the first one to be removed. This method is commonly used in stack data structures.

Key Features of LIFO

1. Last In, First Out: The last element added is the first one to be removed. This means that elements are removed in the reverse order of their addition.
2. Stack Structure: LIFO is often implemented with a stack data structure. A stack supports two primary operations: Push (add an element) and Pop (remove the last added element).

Examples of LIFO

• Program Call Stack: In many programming languages, the call stack is used to manage function calls and their return addresses. The most recently called function frame is the first to be removed when the function completes.
• Browser Back Button: When you visit multiple pages in a web browser, the back button allows you to navigate through the pages in the reverse order of your visits.

How a Stack (LIFO) Works

1. Push: An element is added to the top of the stack.
2. Pop: The element at the top of the stack is removed and returned.

Example in PHP

Here's a simple example of how a stack with LIFO principle can be implemented in PHP:

class Stack {
    private $stack;
    private $size;

    public function __construct() {
        $this->stack = array();
        $this->size = 0;
    }

    // Push operation
    public function push($element) {
        $this->stack[$this->size++] = $element;
    }

    // Pop operation
    public function pop() {
        if ($this->size > 0) {
            return $this->stack[--$this->size];
        } else {
            return null; // Stack is empty
        }
    }

    // Peek operation (optional): returns the top element without removing it
    public function peek() {
        if ($this->size > 0) {
            return $this->stack[$this->size - 1];
        } else {
            return null; // Stack is empty
        }
    }
}

// Example usage
$stack = new Stack();
$stack->push("First");
$stack->push("Second");
$stack->push("Third");

echo $stack->pop(); // Output:

In this example, a stack is created in PHP in which elements are inserted using the push method and removed using the pop method. The output shows that the last element inserted is the first to be removed, demonstrating the LIFO principle.