Min Stack

                            Solution in C :

typedef struct Stack {
    int dataArray[10000];
    int top;
} MinStack;

void minStackGetMinForPush(MinStack*);
int min = 0; // For Minimum Element in the Stack
/** initialize your data structure here. */

MinStack* minStackCreate() {
    static MinStack stack;
    stack.top=-1;
    return &stack;
}

void minStackPush(MinStack* obj, int x) {
    if(obj->top == 10000){
       return;
    }
    else{
        obj->top++;
        obj->dataArray[obj->top] = x;
        minStackGetMinForPush(obj);
    }
}

void minStackPop(MinStack* obj) {
    if(obj->top == -1){
        return;
    } 
    else{
        obj->top--;
    }
    
    if(obj->top == -1){
        return;
    }
    int minTemp = obj->dataArray[obj->top];
    for(int i=0;i<obj->top;i++){
        if(minTemp>obj->dataArray[i]){
           minTemp = obj->dataArray[i];
        }
    }
    min = minTemp;
}

int minStackTop(MinStack* obj) {
    return obj->dataArray[obj->top];
}

int minStackGetMin(MinStack* obj) {
    return min;
}

void minStackGetMinForPush(MinStack* obj){
    // if(obj->top == -1){
    //     return;
    // }
    
    if(obj->top==0){
        min = obj->dataArray[obj->top];
    }
    
    else if(obj->top>0){
        if(min > obj->dataArray[obj->top]){
            min = obj->dataArray[obj->top];
        }
    }
}

void minStackFree(MinStack* obj) {
    obj->top = -1;
}
                        

                        Solution in C++ :

class MinStack {
public:
    typedef struct node{
        int v;
        int minUntilNow;
        node* next;
    }node;

    MinStack() : topN(nullptr){
        
    }
    
    void push(int val) {
        node* n = new node;
        n->v = n->minUntilNow = val;
        n->next = nullptr;
        
        if(topN == nullptr){
            topN = n;
        }

        else{
            n->minUntilNow = min(n->v,topN->minUntilNow);
            n->next = topN;
            topN = n;
        }
    }
    
    void pop() {
        topN = topN->next;
    }
    
    int top() {
        return topN->v;
    }
    
    int getMin() {
        return topN->minUntilNow;
    }

    private:
    node* topN;
};
                    

                        Solution in Java :

class MinStack {
    LinkedList<TplusMin> stack;
    private class TplusMin {
        int val;
        int min;
        public TplusMin(int val, int min) {
            this.val = val;
            this.min = min;
        }
    }

    public MinStack() {
        stack = new LinkedList<>();
    }
    
    public void push(int val) {
        int newMin;
        if (stack.size() == 0){
            newMin = val;
        }
        else {
            int currentMin = stack.getFirst().min;
            newMin = val < currentMin ? val : currentMin;
        }
        stack.addFirst(new TplusMin(val, newMin));
    }
    
    public void pop() {
        stack.removeFirst();
    }
    
    public int top() {
        return stack.peekFirst().val;
    }
    
    public int getMin() {
        return stack.peekFirst().min;
    }
}
                    

                        Solution in Python : 
                            
class MinStack:

    def __init__(self):
        self.stack = []
        self.minStack = []

    def push(self, val: int) -> None:
        self.stack.append(val)
        if self.minStack:
            val = min(self.minStack[-1],val)
        self.minStack.append(val)

    def pop(self) -> None:
        self.stack.pop()
        self.minStack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.minStack[-1]