Skip to content
Related Articles

Related Articles

Design a stack with operations on middle element
  • Difficulty Level : Medium
  • Last Updated : 15 Apr, 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 <bits/stdc++.h>
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 (ME)ANUSHIKA SETH
     {  
           int temp=ms->mid->data;
        ms->mid->prev->next=ms->mid->next;
        ms->mid->next->prev=ms->mid->prev->next;
         
        delete ms->mid;
        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 << "Middle Element is " << findMiddle(ms) << endl;
     cout<<"deleted mid element "<<deletemiddle(ms)<<endl;
    return 0;
}
 
// This code is contributed by rathbhupendra

C




/* Program to implement a stack that supports findMiddle()
   and deleteMiddle in O(1) time */
#include <stdio.h>
#include <stdlib.h>
 
/* 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
Middle Element is 33

Output: 

Item popped is 77
Item popped is 66
Middle Element is 33

 

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
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :