Implementation of stack using Doubly Linked List

Last Updated : 23 Apr, 2025

Stack and doubly linked lists are two important data structures with their own benefits. Stack is a data structure that follows the LIFO (Last In First Out) order and can be implemented using arrays or linked list data structures. Doubly linked list has the advantage that it can also traverse the previous node with the help of “previous” pointer.

Structure of Doubly Linked List

C++

// Declaration of Doubly Linked List class Node { public:     int data;     Node* next;     Node* prev;     Node(int val) {         data = val;         next = nullptr;         prev = nullptr;     } };

Java

// Declaration of Doubly Linked List class Node {     public int data;     public Node next;     public Node prev;      public Node(int val) {         data = val;         next = null;         prev = null;     } }

Python

# Declaration of Doubly Linked List class Node:     def __init__(self, val):         self.data = val         self.next = None         self.prev = None

// Declaration of Doubly Linked List class Node {     public int data;     public Node next;     public Node prev;      public Node(int val) {         data = val;         next = null;         prev = null;     } }

JavaScript

// Declaration of Doubly Linked List class Node {     constructor(val) {         this.data = val;         this.next = null;         this.prev = null;     } }

Stack Functions to be Implemented

Push()

If the stack is empty:
- Create a new node and assign the given data to it.
- Set both the “previous” and “next” pointers of the node to null as it is the first node in the doubly linked list (DLL).
- Assign both “top” and “start” to this new node.
Otherwise:
- Create a new node and assign the given data to it.
- Set the “previous” pointer of the new node to the current “top” node.
- Set the “next” pointer of the new node to null.
- Update the “top” pointer to the new node, as it is now the top element of the stack.

Below is given the implementation:

C++

void push(int val) {     Node* h = new Node(val);      // If stack is empty     // then make the new node as top     if (isEmpty()) {         h->prev = NULL;         h->next = NULL;          // As it is first node         // so it is also top and start         start = h;         top = h;     }     else {         top->next = h;         h->next = NULL;         h->prev = top;         top = h;     } }

Java

void push(int d) {     Node n = new Node();     n.data = d;     if (n.isEmpty()) {         n.prev = null;         n.next = null;          // As it is first node         // if stack is empty         start = n;         top = n;     }     else {         top.next = n;         n.next = null;         n.prev = top;         top = n;     } }

Python

def push(self,element):   newP = node(element)   if self.start == None:      self.start = self.top = newP     return   newP.prev = self.top   self.top.next = newP   self.top = newP

public void Push(int d) {     Node n = new Node();     n.data = d;     if (n.isEmpty())     {         n.prev = null;         n.next = null;          // As it is first node         // if stack is empty         start = n;         top = n;     }     else     {         top.next = n;         n.next = null;         n.prev = top;         top = n;     } }

JavaScript

function push(d) {     var n = new Node();     n.data = d;     if (isEmpty()) {     n.prev = null;     n.next = null;     start = n;     top = n; }  else {     top.next = n;     n.next = null;     n.prev = top;     top = n; }

Pop()

Check if the stack is empty.
- If it is empty, print a message indicating that the stack is empty.
Otherwise:
- Set top->prev->next to null.
- Update top to top->prev.

Below is given the implementation:

C++

void pop() {     Node* n;     n = top;     if (isEmpty())         printf("Stack is empty");     else if (top == start) {         top = NULL;         start = NULL;         free(n);     }     else {         top->prev->next = NULL;         top = n->prev;         free(n);     } }

Java

void pop() {     Node n = top;     if (n.isEmpty())         System.out.println("Stack is empty");     else if (top == start) {         top = null;         start = null;     }     else {         top.prev.next = null;         top = n.prev;     } }

Python

def pop(self):   if self.isEmpty():     print('List is Empty')     return   self.top =  self.top.prev   if self.top != None: self.top.next = None

public void pop() {     Node n ;     n = top;     if (n.isEmpty())         Console.Write("Stack is empty");     else if (top == start) {         top = null;         start = null;         n = null;     }     else {         top.prev.next = null;         top = n.prev;         n = null;     } }

JavaScript

function pop() {     let n;     n = top;     if (isEmpty()) {         console.log("Stack is empty");     }      else if (top === start) {         top = null;         start = null;         free(n);     }      else {         top.prev.next = null;         top = n.prev;         free(n);     } }

isEmpty()

Check the top pointer.
- If top is null, return true.
- Otherwise, return false.

Below is given the implementation:

C++

bool isEmpty() { if (start == nullptr) return true; return false; }

Java

boolean isEmpty() { if (start == null) return true; return false; }

Python

def isEmpty(self): if self.start: return False return True

public bool IsEmpty() {     if (start == null)     {         return true;     }     return false; } // This code is contributed by akashish__

JavaScript

function isEmpty() { return start == null; }

printStack()

Check if the stack is empty.
- If it is empty, print “Stack is empty.”
Otherwise, start from the start node and traverse the doubly linked list until the end.
- Print the data of each node while traversing.

Below is given the implementation:

C++

void printStack() {     if (isEmpty())         printf("Stack is empty");     else {         Node* ptr = start;         while (ptr != NULL) {             printf("%d   ", ptr->data);             ptr = ptr->next;         }         printf("\n");     } }

Java

void printstack() {     if (isEmpty())         System.out.println("Stack is empty");     else {         Node ptr = start;         while (ptr != null) {             System.out.print(ptr.data + " ");             ptr = ptr.next;         }         System.out.println();     } }

Python

def printstack(self):   if self.isEmpty():     print('List is Empty')     return   curr = self.start   while curr != None:     print(curr.val,end = ' ')     curr = curr.next   print()

void PrintStack() {     if (IsEmpty())         Console.WriteLine("Stack is empty");     else {         Node ptr = start;         while (ptr != null) {             Console.Write(ptr.data + " ");             ptr = ptr.next;         }         Console.WriteLine();     } }  // This code is contributed by akashish__

JavaScript

function printStack() {     if (isEmpty()) {         console.log("Stack is empty");     } else {         let ptr = start;         while (ptr != null) {             console.log(ptr.data + " ");             ptr = ptr.next;         }         console.log("\n");     } }

stackSize()

Check if the stack is empty.
- If it is empty, return 0.
Otherwise, initialize a counter and start from the start node.
- Traverse the doubly linked list until the end, incrementing the counter for each node.
Return the final count.

Below is given the implementation:

C++

void stackSize() {     int c = 0;     if (isEmpty())         printf("Stack is empty");     else {         Node* ptr = start;         while (ptr != NULL) {             c++;             ptr = ptr->next;         }     }     printf("%d \n ", c); }

Java

void stackSize() {     int c = 0;     if (isEmpty())         System.out.println("Stack is empty");     else {        Node ptr = start;         while (ptr != null) {             c++;             ptr = ptr.next;         }     }     System.out.println(c); }

Python

def stackSize(self): curr = self.start len = 0 while curr != None: len += 1 curr = curr.next print(len)

static void stackSize() {     int c = 0;     if (IsEmpty())         Console.WriteLine("Stack is empty");     else     {         Node ptr = start;         while (ptr != null)         {             c++;             ptr = ptr.next;         }     }     Console.WriteLine("{0}", c); }

JavaScript

function stackSize() {     let c = 0;     if (isEmpty()) {         console.log("Stack is empty");     } else {         let ptr = start;         while (ptr !== null) {             c++;             ptr = ptr.next;         }     }     console.log(c); }

topElement()

Check if the stack is empty.
- If it is empty, print that there is no top element.
Otherwise, print the data stored in the top node of the stack.

Below is given the implementation:

C++

void topElement() { if (isEmpty()) printf("Stack is empty"); else printf(%d", top->data); }

Java

void topelement() {     if (isEmpty())         System.out.println("Stack is empty");     else         System.out.println(top.data); }

Python

def topelement(self): if self.isEmpty(): print("Stack is empty") else: print(self.top.val)

void TopElement() {     if (IsEmpty())         Console.WriteLine("Stack is empty");     else         Console.WriteLine(top.data); }

JavaScript

function topElement() {     if (isEmpty()) {         console.log("Stack is empty");     } else {         console.log(top.data);     } }