Implement a stack using singly linked list

24 Jun, 2022
To implement a stack using singly linked list concept , all the singly linked list operations are performed based on Stack operations LIFO(last in first out) and with the help of that knowledge we are going to implement a stack using single linked list. Using singly linked lists , we implement stack by storing the information in the form of nodes and we need to follow the stack rules and implement using singly linked list nodes . So we need to follow a simple rule in the implementation of a stack which is last in first out and all the operations can be performed with the help of a top variable .Let us learn how to perform Pop , Push , Peek ,Display operations in the following article .  
A stack can be easily implemented using the linked list. In stack Implementation, a stack contains a top pointer. which is “head” of the stack where pushing and popping items happens at the head of the list. First node have null in link field and second node link have first node address in link field and so on and last node address in “top” pointer.The main advantage of using linked list over an arrays is that it is possible to implement a stack that can shrink or grow as much as needed. In using array will put a restriction to the maximum capacity of the array which can lead to stack overflow. Here each new node will be dynamically allocate. so overflow is not possible.Stack Operations: 
push() : Insert a new element into stack i.e just inserting a new element at the beginning of the linked list.pop() : Return top element of the Stack i.e simply deleting the first element from the linked list.peek(): Return the top element.display(): Print all elements in Stack.
push() : Insert a new element into stack i.e just inserting a new element at the beginning of the linked list.
pop() : Return top element of the Stack i.e simply deleting the first element from the linked list.
peek(): Return the top element.
display(): Print all elements in Stack.
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ program to Implement a stack//using singly linked list#include <bits/stdc++.h>using namespace std;  // Declare linked list node  struct Node{    int data;    Node* link;};  Node* top;  // Utility function to add an element// data in the stack insert at the beginningvoid push(int data){          // Create new node temp and allocate memory in heap    Node* temp = new Node();      // Check if stack (heap) is full.    // Then inserting an element would    // lead to stack overflow    if (!temp)    {        cout << "\nStack Overflow";        exit(1);    }      // Initialize data into temp data field    temp->data = data;      // Put top pointer reference into temp link    temp->link = top;      // Make temp as top of Stack    top = temp;}  // Utility function to check if// the stack is empty or notint isEmpty(){    //If top is NULL it means that     //there are no elements are in stack    return top == NULL;}  // Utility function to return top element in a stackint peek(){          // If stack is not empty , return the top element    if (!isEmpty())        return top->data;    else        exit(1);}  // Utility function to pop top// element from the stackvoid pop(){    Node* temp;      // Check for stack underflow    if (top == NULL)    {        cout << "\nStack Underflow" << endl;        exit(1);    }    else    {                  // Assign top to temp        temp = top;          // Assign second node to top        top = top->link;          //This will automatically destroy         //the link between first node and second node          // Release memory of top node        //i.e delete the node        free(temp);    }}  // Function to print all the// elements of the stackvoid display(){    Node* temp;      // Check for stack underflow    if (top == NULL)    {        cout << "\nStack Underflow";        exit(1);    }    else    {        temp = top;        while (temp != NULL)        {              // Print node data            cout << temp->data << "-> ";              // Assign temp link to temp            temp = temp->link;        }    }}  // Driver Codeint main(){          // Push the elements of stack    push(11);    push(22);    push(33);    push(44);      // Display stack elements    display();      // Print top element of stack    cout << "\nTop element is "        << peek() << endl;      // Delete top elements of stack    pop();    pop();      // Display stack elements    display();      // Print top element of stack    cout << "\nTop element is "        << peek() << endl;              return 0;}
// Java program to Implement a stack// using singly linked list// import packageimport static java.lang.System.exit;  // Create Stack Using Linked listclass StackUsingLinkedlist {      // A linked list node    private class Node {          int data; // integer data        Node link; // reference variable Node type    }    // create global top reference variable global    Node top;    // Constructor    StackUsingLinkedlist()    {        this.top = null;    }      // Utility function to add an element x in the stack    public void push(int x) // insert at the beginning    {        // create new node temp and allocate memory        Node temp = new Node();          // check if stack (heap) is full. Then inserting an        //  element would lead to stack overflow        if (temp == null) {            System.out.print("\nHeap Overflow");            return;        }          // initialize data into temp data field        temp.data = x;          // put top reference into temp link        temp.link = top;          // update top reference        top = temp;    }      // Utility function to check if the stack is empty or not    public boolean isEmpty()    {        return top == null;    }      // Utility function to return top element in a stack    public int peek()    {        // check for empty stack        if (!isEmpty()) {            return top.data;        }        else {            System.out.println("Stack is empty");            return -1;        }    }      // Utility function to pop top element from the stack    public void pop() // remove at the beginning    {        // check for stack underflow        if (top == null) {            System.out.print("\nStack Underflow");            return;        }          // update the top pointer to point to the next node        top = (top).link;    }      public void display()    {        // check for stack underflow        if (top == null) {            System.out.printf("\nStack Underflow");            exit(1);        }        else {            Node temp = top;            while (temp != null) {                  // print node data                System.out.printf("%d->", temp.data);                  // assign temp link to temp                temp = temp.link;            }        }    }}// main classpublic class GFG {    public static void main(String[] args)    {        // create Object of Implementing class        StackUsingLinkedlist obj = new StackUsingLinkedlist();        // insert Stack value        obj.push(11);        obj.push(22);        obj.push(33);        obj.push(44);          // print Stack elements        obj.display();          // print Top element of Stack        System.out.printf("\nTop element is %d\n", obj.peek());          // Delete top element of Stack        obj.pop();        obj.pop();          // print Stack elements        obj.display();          // print Top element of Stack        System.out.printf("\nTop element is %d\n", obj.peek());    }}
'''Python supports automatic garbage collection so deallocation of memoryis done implicitly. However to force it to deallocate each node after use,add the following code:      import gc         #added at the start of program    gc.collect()     #to be added wherever memory is to be deallocated'''  class Node:          # Class to create nodes of linked list    # constructor initializes node automatically    def __init__(self,data):        self.data = data        self.next = None      class Stack:          # head is default NULL    def __init__(self):        self.head = None          # Checks if stack is empty    def isempty(self):        if self.head == None:            return True        else:            return False          # Method to add data to the stack    # adds to the start of the stack    def push(self,data):                  if self.head == None:            self.head=Node(data)                      else:            newnode = Node(data)            newnode.next = self.head            self.head = newnode          # Remove element that is the current head (start of the stack)    def pop(self):                  if self.isempty():            return None                      else:            # Removes the head node and makes             #the preceding one the new head            poppednode = self.head            self.head = self.head.next            poppednode.next = None            return poppednode.data          # Returns the head node data    def peek(self):                  if self.isempty():            return None                      else:            return self.head.data          # Prints out the stack         def display(self):                  iternode = self.head        if self.isempty():            print("Stack Underflow")                  else:                          while(iternode != None):                                  print(iternode.data,"->",end = " ")                iternode = iternode.next            return          # Driver codeMyStack = Stack()  MyStack.push(11) MyStack.push(22)MyStack.push(33)MyStack.push(44)  # Display stack elements MyStack.display()  # Print top element of stack print("\nTop element is ",MyStack.peek())  # Delete top elements of stack MyStack.pop()MyStack.pop()  # Display stack elementsMyStack.display()  # Print top element of stack print("\nTop element is ", MyStack.peek())   # This code is contributed by Mathew George
// C# program to Implement a stack // using singly linked list // import packageusing System;   // Create Stack Using Linked list public class StackUsingLinkedlist {       // A linked list node     private class Node    {         // integer data         public int data;                   // reference variable Node type         public Node link;     }           // create global top reference variable     Node top;           // Constructor     public StackUsingLinkedlist()     {         this.top = null;     }       // Utility function to add     // an element x in the stack     // insert at the beginning     public void push(int x)     {         // create new node temp and allocate memory         Node temp = new Node();           // check if stack (heap) is full.         // Then inserting an element        // would lead to stack overflow         if (temp == null)         {             Console.Write("\nHeap Overflow");             return;         }           // initialize data into temp data field         temp.data = x;           // put top reference into temp link         temp.link = top;           // update top reference         top = temp;     }       // Utility function to check if    // the stack is empty or not     public bool isEmpty()     {         return top == null;     }       // Utility function to return    // top element in a stack     public int peek()     {         // check for empty stack         if (!isEmpty())         {             return top.data;         }         else        {             Console.WriteLine("Stack is empty");             return -1;         }     }       // Utility function to pop top element from the stack     public void pop() // remove at the beginning     {         // check for stack underflow         if (top == null)        {             Console.Write("\nStack Underflow");             return;         }           // update the top pointer to         // point to the next node         top = (top).link;     }       public void display()     {         // check for stack underflow         if (top == null)         {             Console.Write("\nStack Underflow");             return;         }         else         {             Node temp = top;             while (temp != null)             {                   // print node data                 Console.Write("{0}->", temp.data);                   // assign temp link to temp                 temp = temp.link;             }         }     } }   // Driver code public class GFG {     public static void Main(String[] args)     {         // create Object of Implementing class         StackUsingLinkedlist obj = new StackUsingLinkedlist();                   // insert Stack value         obj.push(11);         obj.push(22);         obj.push(33);         obj.push(44);           // print Stack elements         obj.display();           // print Top element of Stack         Console.Write("\nTop element is {0}\n", obj.peek());           // Delete top element of Stack         obj.pop();         obj.pop();           // print Stack elements         obj.display();           // print Top element of Stack         Console.Write("\nTop element is {0}\n", obj.peek());     } }  // This code is contributed by 29AjayKumar
<script>// Javascript program to Implement a stack// using singly linked list// import package  // A linked list nodeclass Node{    constructor()    {        this.data=0;        this.link=null;    }}  // Create Stack Using Linked listclass StackUsingLinkedlist{    constructor()    {        this.top=null;    }          // Utility function to add an element x in the stack    push(x)    {        // create new node temp and allocate memory        let temp = new Node();           // check if stack (heap) is full. Then inserting an        //  element would lead to stack overflow        if (temp == null) {            document.write("<br>Heap Overflow");            return;        }           // initialize data into temp data field        temp.data = x;           // put top reference into temp link        temp.link = this.top;           // update top reference        this.top = temp;    }           // Utility function to check if the stack is empty or not    isEmpty()    {         return this.top == null;    }          // Utility function to return top element in a stack        peek()    {        // check for empty stack        if (!this.isEmpty()) {            return this.top.data;        }        else {            document.write("Stack is empty<br>");            return -1;        }    }          // Utility function to pop top element from the stack    pop() // remove at the beginning    {        // check for stack underflow        if (this.top == null) {            document.write("<br>Stack Underflow");            return;        }           // update the top pointer to point to the next node        this.top = this.top.link;    }          display()    {        // check for stack underflow        if (this.top == null) {            document.write("<br>Stack Underflow");                      }        else {            let temp = this.top;            while (temp != null) {                   // print node data                document.write(temp.data+"->");                   // assign temp link to temp                temp = temp.link;            }        }    }}  // main class  // create Object of Implementing classlet obj = new StackUsingLinkedlist();// insert Stack valueobj.push(11);obj.push(22);obj.push(33);obj.push(44);  // print Stack elementsobj.display();  // print Top element of Stackdocument.write("<br>Top element is ", obj.peek()+"<br>");  // Delete top element of Stackobj.pop();obj.pop();  // print Stack elementsobj.display();  // print Top element of Stackdocument.write("<br>Top element is ", obj.peek()+"<br>");  // This code is contributed by rag2127</script>
Output:
44->33->22->11->
Top element is 44
22->11->
Top element is 22
The time complexity for all push(), pop(), and peek() operations is O(1) as we are not performing any kind of traversal over the list. We perform all the operations through the current pointer only.
Space complexity: O(n) where n is size of the stack
Implement stack using Linked List | GeeksforGeeks - YouTubeGeeksforGeeks530K subscribersImplement stack using Linked List | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 23:27•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=Ebq7QUPaU7I" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
29AjayKumar
AmAnhasNoName
SumanyuChaudhary
7knight
ryadav2
rag2127
gabaa406
geethika1129
polymatir3j
Technical Scripter 2018
Linked List
Stack
Technical Scripter
Linked List
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
LinkedList in Java
Introduction to Data Structures
Doubly Linked List | Set 1 (Introduction and Insertion)
Detect loop in a linked list
Merge two sorted linked lists
Stack in Python
Stack Class in Java
Check for Balanced Brackets in an expression (well-formedness) using Stack
Introduction to Data Structures
Queue using Stacks