Representation of a Stack as a Linked List in Java .

Stack implementation using linked list

Representation of a Stack as a Linked List.

A Stack is a linear data structure that follows the principle of (Last-In-First-Out) LIFO . In Stack  there is one end through which insertion and deletion takes place.  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.

Stack can also be represented by using a linked list. We know that in the case of arrays we face a limitation , i.e , array is a data structure of limited size. Hence before using an array to represent a stack we will have to consider an enough amount of space to hold the memory required by the stack.

 

Operation in stack:

Following are common operations implemented on the stack:

  • push():When we insert an element in a stack then the operation is known as a push. If the stack is full then the condition is called overflow condition.
  • pop(): When we want to delete an element from the stack, the operation is known as a pop. If the stack is empty means there is no element in the stack, this condition is known as an underflow state.
  • isEmpty():When we want to determines whether the stack is empty or not.
  • isFull(): when we want to determines whether the stack is full or not.’
  • peek(): It returns the element at the given position.

                                                                                     

Implementation of a Stack using a Linked List:

A push operation is implemented by inserting an element at the beginning of the list.

A pop operation is implemented by deleting the node from the beginning (the header/top node).

Java code :


// Java Code for Linked List Implementation

public class LinkedList {

    stacknode node;

    static class stacknode {
        int data;
        stacknode next;

        stacknode(int data) { this.data = data; }
    }

    public boolean isEmpty()
    {
        if (node == null) {
            return true;
        }
        else
            return false;
    }

    public void push(int data)
    {
        stacknode newNode = new stacknode(data);

        if (node == null) {
            node = newNode;
        }
        else {
            stacknode temp = node;
            node = newNode;
            newNode.next = temp;
        }
        System.out.println(data);
    }

    public int pop()
    {
        int popped = Integer.MIN_VALUE;
        if (node == null) {
            System.out.println(“Stack is Empty”);
        }
        else {
            popped = node.data;
            node = node.next;
        }
        return popped;
    }

    public int peek()
    {
        if (node == null) {
            System.out.println(“Stack is empty”);
            return Integer.MIN_VALUE;
        }
        else {
            return node.data;
        }
    }

    
    public static void main(String[] args)
    {

        LinkedList sll = new LinkedList();

        slk.push(20);
        slk.push(40);
        slk.push(60);

        System.out.println(slk.pop());

        System.out.println(“Top element is “ + slk.peek());
    }
}
Output :

Top element is 60