Skip to content
Related Articles
Design a stack with operations on middle element
• Difficulty Level : Medium
• Last Updated : 31 May, 2021

How to implement a stack which will support following operations in O(1) time complexity
1) push() which adds an element to the top of stack.
2) pop() which removes an element from top of stack.
3) findMiddle() which will return middle element of the stack.
4) deleteMiddle() which will delete the middle element.
Push and pop are standard stack operations.
The important question is, whether to use a linked list or array for implementation of stack?
Please note that, we need to find and delete middle element. Deleting an element from middle is not O(1) for array. Also, we may need to move the middle pointer up when we push an element and move down when we pop(). In singly linked list, moving middle pointer in both directions is not possible.
The idea is to use Doubly Linked List (DLL). We can delete middle element in O(1) time by maintaining mid pointer. We can move mid pointer in both directions using previous and next pointers.
Following is implementation of push(), pop() and findMiddle() operations. Implementation of deleteMiddle() is left as an exercise. If there are even elements in stack, findMiddle() returns the second middle element. For example, if stack contains {1, 2, 3, 4}, then findMiddle() would return 3.

## C++

 `/* C++ Program to implement a stack``that supports findMiddle() and``deleteMiddle in O(1) time */``#include ``using` `namespace` `std;` `/* A Doubly Linked List Node */``class` `DLLNode {``public``:``    ``DLLNode* prev;``    ``int` `data;``    ``DLLNode* next;``};` `/* Representation of the stack data structure``that supports findMiddle() in O(1) time.``The Stack is implemented using Doubly Linked List.``It maintains pointer to head node, pointer to``middle node and count of nodes */``class` `myStack {``public``:``    ``DLLNode* head;``    ``DLLNode* mid;``    ``int` `count;``};` `/* Function to create the stack data structure */``myStack* createMyStack()``{``    ``myStack* ms = ``new` `myStack();``    ``ms->count = 0;``    ``return` `ms;``};` `/* Function to push an element to the stack */``void` `push(myStack* ms, ``int` `new_data)``{``    ``/* allocate DLLNode and put in data */``    ``DLLNode* new_DLLNode = ``new` `DLLNode();``    ``new_DLLNode->data = new_data;` `    ``/* Since we are adding at the beginning,``    ``prev is always NULL */``    ``new_DLLNode->prev = NULL;` `    ``/* link the old list off the new DLLNode */``    ``new_DLLNode->next = ms->head;` `    ``/* Increment count of items in stack */``    ``ms->count += 1;` `    ``/* Change mid pointer in two cases``    ``1) Linked List is empty``    ``2) Number of nodes in linked list is odd */``    ``if` `(ms->count == 1) {``        ``ms->mid = new_DLLNode;``    ``}``    ``else` `{``        ``ms->head->prev = new_DLLNode;` `        ``if` `(!(ms->count``              ``& 1)) ``// Update mid if ms->count is even``            ``ms->mid = ms->mid->prev;``    ``}` `    ``/* move head to point to the new DLLNode */``    ``ms->head = new_DLLNode;``}` `/* Function to pop an element from stack */``int` `pop(myStack* ms)``{``    ``/* Stack underflow */``    ``if` `(ms->count == 0) {``        ``cout << ``"Stack is empty\n"``;``        ``return` `-1;``    ``}` `    ``DLLNode* head = ms->head;``    ``int` `item = head->data;``    ``ms->head = head->next;` `    ``// If linked list doesn't``    ``// become empty, update prev``    ``// of new head as NULL``    ``if` `(ms->head != NULL)``        ``ms->head->prev = NULL;` `    ``ms->count -= 1;` `    ``// update the mid pointer when``    ``// we have odd number of``    ``// elements in the stack, i,e``    ``// move down the mid pointer.``    ``if` `((ms->count) & 1)``        ``ms->mid = ms->mid->next;` `    ``free``(head);` `    ``return` `item;``}` `// Function for finding middle of the stack``int` `findMiddle(myStack* ms)``{``    ``if` `(ms->count == 0) {``        ``cout << ``"Stack is empty now\n"``;``        ``return` `-1;``    ``}` `    ``return` `ms->mid->data;``  ` `}``// Function for deleting middle of the stack``int`  `deletemiddle(myStack* ms)   ``// IMPROVED BY Sohaib Ayub``     ``{  ``           ``int` `temp=ms->mid->data;``        ``ms->mid->prev->next=ms->mid->next;``        ``ms->mid->next->prev=ms->mid->prev->next;``        ` `        ``delete` `ms->mid;``          ``ms->mid = ms->mid->next; ``//So that mid does not contain garbage value``        ``return` `temp;``     ``}`     `// Driver code``int` `main()``{``    ``/* Let us create a stack using push() operation*/``    ``myStack* ms = createMyStack();``    ``push(ms, 11);``    ``push(ms, 22);``    ``push(ms, 33);``    ``push(ms, 44);``    ``push(ms, 55);``    ``push(ms, 66);``    ``push(ms, 77);` `    ``cout << ``"Item popped is "` `<< pop(ms) << endl;``    ``cout << ``"Item popped is "` `<< pop(ms) << endl;``    ``cout << ``"Item popped is "` `<< pop(ms) << endl;``    ``cout << ``"Middle Element is "` `<< findMiddle(ms) << endl;``    ``cout << ``"Deleted Middle Element is "``<

## C

 `/* Program to implement a stack that supports findMiddle()``   ``and deleteMiddle in O(1) time */``#include ``#include ` `/* A Doubly Linked List Node */``struct` `DLLNode {``    ``struct` `DLLNode* prev;``    ``int` `data;``    ``struct` `DLLNode* next;``};` `/* Representation of the stack data structure that supports``   ``findMiddle() in O(1) time.  The Stack is implemented``   ``using Doubly Linked List. It maintains pointer to head``   ``node, pointer to middle node and count of nodes */``struct` `myStack {``    ``struct` `DLLNode* head;``    ``struct` `DLLNode* mid;``    ``int` `count;``};` `/* Function to create the stack data structure */``struct` `myStack* createMyStack()``{``    ``struct` `myStack* ms``        ``= (``struct` `myStack*)``malloc``(``sizeof``(``struct` `myStack));``    ``ms->count = 0;``    ``return` `ms;``};` `/* Function to push an element to the stack */``void` `push(``struct` `myStack* ms, ``int` `new_data)``{``    ``/* allocate DLLNode and put in data */``    ``struct` `DLLNode* new_DLLNode``        ``= (``struct` `DLLNode*)``malloc``(``sizeof``(``struct` `DLLNode));``    ``new_DLLNode->data = new_data;` `    ``/* Since we are adding at the beginning,``      ``prev is always NULL */``    ``new_DLLNode->prev = NULL;` `    ``/* link the old list off the new DLLNode */``    ``new_DLLNode->next = ms->head;` `    ``/* Increment count of items in stack */``    ``ms->count += 1;` `    ``/* Change mid pointer in two cases``       ``1) Linked List is empty``       ``2) Number of nodes in linked list is odd */``    ``if` `(ms->count == 1) {``        ``ms->mid = new_DLLNode;``    ``}``    ``else` `{``        ``ms->head->prev = new_DLLNode;` `        ``if` `(ms->count & 1) ``// Update mid if ms->count is odd``            ``ms->mid = ms->mid->prev;``    ``}` `    ``/* move head to point to the new DLLNode */``    ``ms->head = new_DLLNode;``}` `/* Function to pop an element from stack */``int` `pop(``struct` `myStack* ms)``{``    ``/* Stack underflow */``    ``if` `(ms->count == 0) {``        ``printf``(``"Stack is empty\n"``);``        ``return` `-1;``    ``}` `    ``struct` `DLLNode* head = ms->head;``    ``int` `item = head->data;``    ``ms->head = head->next;` `    ``// If linked list doesn't become empty, update prev``    ``// of new head as NULL``    ``if` `(ms->head != NULL)``        ``ms->head->prev = NULL;` `    ``ms->count -= 1;` `    ``// update the mid pointer when we have even number of``    ``// elements in the stack, i,e move down the mid pointer.``    ``if` `(!((ms->count) & 1))``        ``ms->mid = ms->mid->next;` `    ``free``(head);` `    ``return` `item;``}` `// Function for finding middle of the stack``int` `findMiddle(``struct` `myStack* ms)``{``    ``if` `(ms->count == 0) {``        ``printf``(``"Stack is empty now\n"``);``        ``return` `-1;``    ``}` `    ``return` `ms->mid->data;``}` `// Driver program to test functions of myStack``int` `main()``{``    ``/* Let us create a stack using push() operation*/``    ``struct` `myStack* ms = createMyStack();``    ``push(ms, 11);``    ``push(ms, 22);``    ``push(ms, 33);``    ``push(ms, 44);``    ``push(ms, 55);``    ``push(ms, 66);``    ``push(ms, 77);` `    ``printf``(``"Item popped is %d\n"``, pop(ms));``    ``printf``(``"Item popped is %d\n"``, pop(ms));``    ``printf``(``"Middle Element is %d\n"``, findMiddle(ms));``    ``return` `0;``}`

## Java

 `/* Java Program to implement a stack that supports``findMiddle() and deleteMiddle in O(1) time */` `public` `class` `GFG {``    ``/* A Doubly Linked List Node */``    ``class` `DLLNode {``        ``DLLNode prev;``        ``int` `data;``        ``DLLNode next;``        ``DLLNode(``int` `d) { data = d; }``    ``}` `    ``/* Representation of the stack data structure that``       ``supports findMiddle() in O(1) time.  The Stack is``       ``implemented using Doubly Linked List. It maintains``       ``pointer to head node, pointer to middle node and``       ``count of nodes */``    ``class` `myStack {``        ``DLLNode head;``        ``DLLNode mid;``        ``int` `count;``    ``}` `    ``/* Function to create the stack data structure */``    ``myStack createMyStack()``    ``{``        ``myStack ms = ``new` `myStack();``        ``ms.count = ``0``;``        ``return` `ms;``    ``}` `    ``/* Function to push an element to the stack */``    ``void` `push(myStack ms, ``int` `new_data)``    ``{` `        ``/* allocate DLLNode and put in data */``        ``DLLNode new_DLLNode = ``new` `DLLNode(new_data);` `        ``/* Since we are adding at the beginning,``          ``prev is always NULL */``        ``new_DLLNode.prev = ``null``;` `        ``/* link the old list off the new DLLNode */``        ``new_DLLNode.next = ms.head;` `        ``/* Increment count of items in stack */``        ``ms.count += ``1``;` `        ``/* Change mid pointer in two cases``           ``1) Linked List is empty``           ``2) Number of nodes in linked list is odd */``        ``if` `(ms.count == ``1``) {``            ``ms.mid = new_DLLNode;``        ``}``        ``else` `{``            ``ms.head.prev = new_DLLNode;` `            ``if` `((ms.count % ``2``)``                ``!= ``0``) ``// Update mid if ms->count is odd``                ``ms.mid = ms.mid.prev;``        ``}` `        ``/* move head to point to the new DLLNode */``        ``ms.head = new_DLLNode;``    ``}` `    ``/* Function to pop an element from stack */``    ``int` `pop(myStack ms)``    ``{``        ``/* Stack underflow */``        ``if` `(ms.count == ``0``) {``            ``System.out.println(``"Stack is empty"``);``            ``return` `-``1``;``        ``}` `        ``DLLNode head = ms.head;``        ``int` `item = head.data;``        ``ms.head = head.next;` `        ``// If linked list doesn't become empty, update prev``        ``// of new head as NULL``        ``if` `(ms.head != ``null``)``            ``ms.head.prev = ``null``;` `        ``ms.count -= ``1``;` `        ``// update the mid pointer when we have even number``        ``// of elements in the stack, i,e move down the mid``        ``// pointer.``        ``if` `(ms.count % ``2` `== ``0``)``            ``ms.mid = ms.mid.next;` `        ``return` `item;``    ``}` `    ``// Function for finding middle of the stack``    ``int` `findMiddle(myStack ms)``    ``{``        ``if` `(ms.count == ``0``) {``            ``System.out.println(``"Stack is empty now"``);``            ``return` `-``1``;``        ``}``        ``return` `ms.mid.data;``    ``}` `    ``// Driver program to test functions of myStack``    ``public` `static` `void` `main(String args[])``    ``{``        ``GFG ob = ``new` `GFG();``        ``myStack ms = ob.createMyStack();``        ``ob.push(ms, ``11``);``        ``ob.push(ms, ``22``);``        ``ob.push(ms, ``33``);``        ``ob.push(ms, ``44``);``        ``ob.push(ms, ``55``);``        ``ob.push(ms, ``66``);``        ``ob.push(ms, ``77``);` `        ``System.out.println(``"Item popped is "` `+ ob.pop(ms));``        ``System.out.println(``"Item popped is "` `+ ob.pop(ms));``        ``System.out.println(``"Middle Element is "``                           ``+ ob.findMiddle(ms));``    ``}``}` `// This code is contributed by Sumit Ghosh`

## Python3

 `''' Python3 Program to implement a stack``that supports findMiddle()``and deleteMiddle in O(1) time '''` `''' A Doubly Linked List Node '''`  `class` `DLLNode:` `    ``def` `__init__(``self``, d):``        ``self``.prev ``=` `None``        ``self``.data ``=` `d``        ``self``.``next` `=` `None`  `''' Representation of the stack``data structure that supports``findMiddle() in O(1) time. The``Stack is implemented using``Doubly Linked List. It maintains``pointer to head node, pointer``to middle node and count of``nodes '''`  `class` `myStack:` `    ``def` `__init__(``self``):``        ``self``.head ``=` `None``        ``self``.mid ``=` `None``        ``self``.count ``=` `0`  `''' Function to create the stack data structure '''`  `def` `createMyStack():``    ``ms ``=` `myStack()``    ``ms.count ``=` `0``    ``return` `ms`  `''' Function to push an element to the stack '''`  `def` `push(ms, new_data):``    ``''' allocate DLLNode and put in data '''``    ``new_DLLNode ``=` `DLLNode(new_data)` `    ``''' Since we are adding at the beginning,``    ``prev is always NULL '''``    ``new_DLLNode.prev ``=` `None` `    ``''' link the old list off the new DLLNode '''``    ``new_DLLNode.``next` `=` `ms.head` `    ``''' Increment count of items in stack '''``    ``ms.count ``+``=` `1` `    ``''' Change mid pointer in two cases``    ``1) Linked List is empty``    ``2) Number of nodes in linked list is odd '''``    ``if``(ms.count ``=``=` `1``):``        ``ms.mid ``=` `new_DLLNode` `    ``else``:``        ``ms.head.prev ``=` `new_DLLNode` `        ``# Update mid if ms->count is odd``        ``if``((ms.count ``%` `2``) !``=` `0``):``            ``ms.mid ``=` `ms.mid.prev` `    ``''' move head to point to the new DLLNode '''``    ``ms.head ``=` `new_DLLNode`  `''' Function to pop an element from stack '''`  `def` `pop(ms):``    ``''' Stack underflow '''``    ``if``(ms.count ``=``=` `0``):` `        ``print``(``"Stack is empty"``)``        ``return` `-``1` `    ``head ``=` `ms.head``    ``item ``=` `head.data``    ``ms.head ``=` `head.``next` `    ``# If linked list doesn't become empty,``    ``# update prev of new head as NULL``    ``if``(ms.head !``=` `None``):``        ``ms.head.prev ``=` `None``    ``ms.count ``-``=` `1` `    ``# update the mid pointer when``    ``# we have even number of elements``    ``# in the stack, i,e move down``    ``# the mid pointer.``    ``if``(ms.count ``%` `2` `=``=` `0``):``        ``ms.mid ``=` `ms.mid.``next``    ``return` `item` `# Function for finding middle of the stack`  `def` `findMiddle(ms):``    ``if``(ms.count ``=``=` `0``):``        ``print``(``"Stack is empty now"``)``        ``return` `-``1``    ``return` `ms.mid.data`  `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``ms ``=` `createMyStack()``    ``push(ms, ``11``)``    ``push(ms, ``22``)``    ``push(ms, ``33``)``    ``push(ms, ``44``)``    ``push(ms, ``55``)``    ``push(ms, ``66``)``    ``push(ms, ``77``)` `    ``print``(``"Item popped is "` `+``          ``str``(pop(ms)))``    ``print``(``"Item popped is "` `+``          ``str``(pop(ms)))``    ``print``(``"Middle Element is "` `+``          ``str``(findMiddle(ms)))` `    ``# This code is contributed by rutvik_56.`

## C#

 `/* C# Program to implement a stack``that supports findMiddle()``and deleteMiddle in O(1) time */``using` `System;` `class` `GFG {``    ``/* A Doubly Linked List Node */``    ``public` `class` `DLLNode {``        ``public` `DLLNode prev;``        ``public` `int` `data;``        ``public` `DLLNode next;``        ``public` `DLLNode(``int` `d) { data = d; }``    ``}` `    ``/* Representation of the stack``    ``data structure that supports``    ``findMiddle() in O(1) time. The``    ``Stack is implemented using``    ``Doubly Linked List. It maintains``    ``pointer to head node, pointer``    ``to middle node and count of``    ``nodes */``    ``public` `class` `myStack {``        ``public` `DLLNode head;``        ``public` `DLLNode mid;``        ``public` `int` `count;``    ``}` `    ``/* Function to create the stack data structure */``    ``myStack createMyStack()``    ``{``        ``myStack ms = ``new` `myStack();``        ``ms.count = 0;``        ``return` `ms;``    ``}` `    ``/* Function to push an element to the stack */``    ``void` `push(myStack ms, ``int` `new_data)``    ``{` `        ``/* allocate DLLNode and put in data */``        ``DLLNode new_DLLNode = ``new` `DLLNode(new_data);` `        ``/* Since we are adding at the beginning,``        ``prev is always NULL */``        ``new_DLLNode.prev = ``null``;` `        ``/* link the old list off the new DLLNode */``        ``new_DLLNode.next = ms.head;` `        ``/* Increment count of items in stack */``        ``ms.count += 1;` `        ``/* Change mid pointer in two cases``        ``1) Linked List is empty``        ``2) Number of nodes in linked list is odd */``        ``if` `(ms.count == 1) {``            ``ms.mid = new_DLLNode;``        ``}``        ``else` `{``            ``ms.head.prev = new_DLLNode;` `            ``// Update mid if ms->count is odd``            ``if` `((ms.count % 2) != 0)``                ``ms.mid = ms.mid.prev;``        ``}` `        ``/* move head to point to the new DLLNode */``        ``ms.head = new_DLLNode;``    ``}` `    ``/* Function to pop an element from stack */``    ``int` `pop(myStack ms)``    ``{``        ``/* Stack underflow */``        ``if` `(ms.count == 0) {``            ``Console.WriteLine(``"Stack is empty"``);``            ``return` `-1;``        ``}` `        ``DLLNode head = ms.head;``        ``int` `item = head.data;``        ``ms.head = head.next;` `        ``// If linked list doesn't become empty,``        ``// update prev of new head as NULL``        ``if` `(ms.head != ``null``)``            ``ms.head.prev = ``null``;` `        ``ms.count -= 1;` `        ``// update the mid pointer when``        ``// we have even number of elements``        ``// in the stack, i,e move down``        ``// the mid pointer.``        ``if` `(ms.count % 2 == 0)``            ``ms.mid = ms.mid.next;` `        ``return` `item;``    ``}` `    ``// Function for finding middle of the stack``    ``int` `findMiddle(myStack ms)``    ``{``        ``if` `(ms.count == 0) {``            ``Console.WriteLine(``"Stack is empty now"``);``            ``return` `-1;``        ``}``        ``return` `ms.mid.data;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``GFG ob = ``new` `GFG();``        ``myStack ms = ob.createMyStack();``        ``ob.push(ms, 11);``        ``ob.push(ms, 22);``        ``ob.push(ms, 33);``        ``ob.push(ms, 44);``        ``ob.push(ms, 55);``        ``ob.push(ms, 66);``        ``ob.push(ms, 77);` `        ``Console.WriteLine(``"Item popped is "` `+ ob.pop(ms));``        ``Console.WriteLine(``"Item popped is "` `+ ob.pop(ms));``        ``Console.WriteLine(``"Middle Element is "``                          ``+ ob.findMiddle(ms));``    ``}``}` `// This code is contributed``// by Arnab Kundu`
Output
```Item popped is 77
Item popped is 66
Item popped is 55
Middle Element is 33
Deleted Middle Element is 33
Middle Element is 22
```

This article is contributed by Chandra Prakash. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up