leetcode Min stack

It is very easy to get idea of this problem. Just use an auxiliary stack (s_a) to store the current minimum element in the data stack (s_d). 
But leetcode has a strong constrain in the memory size, always get MLE error. 


You cannot push current minimum element into the s_a stack if the data pushed to s_d is not the minimum one. 
But I got confused why I implement this kind of stack with linked list it get MLE, but when I change to STL deque to implement it, it got AC


Linked list version:

using namespace std;

struct lkNode {
	lkNode* next;
	int data;
	lkNode(int x){next = NULL; data = x;}
};

class MinStack {
private:
	lkNode* p_top;
	lkNode* p_min_top;
public:
    void push(int x) {
    	lkNode* tmp = new lkNode(x);
    	tmp->next = p_top;
    	p_top = tmp;
    	if (p_min_top == NULL) {
    		p_min_top = new lkNode(tmp->data);
    	}
    	else {
    		if (x <= p_min_top->data) {
    		    lkNode* min_tmp;
    			min_tmp = new lkNode(x);
    		    min_tmp->next = p_min_top;
    		    p_min_top = min_tmp;
            }
    	}
    }

    void pop() {
    	lkNode* tmp = p_top;
    	p_top = tmp->next;
        if (tmp->data == p_min_top->data) {
    	    lkNode* min_tmp = p_min_top;
    	    p_min_top = min_tmp->next;
            delete min_tmp;
        }
    	delete tmp;
    }

    int top() {
    	return p_top->data;
    }

    int getMin() {
    	return p_min_top->data;
    }
};

deque version:

#include <iostream>
#include <deque>

using namespace std;

class MinStack {
private:
    deque<int> stack;
    deque<int> min;
public:
    void push(int x) {
        stack.push_back(x);
        if (min.empty() || x <= min.back()) {
            min.push_back(x);
        }   
    }
    
    void pop() {
        if (stack.back() ==  min.back()) {
            min.pop_back();
        }
        stack.pop_back();
    }
    
    int top() {
        return stack.back();
    }

    int getMin() {
        return min.back();
    }
};

I know the STL deque must be more efficient than I write. But what the problem of my linked list version. The space complexity is O(n) also. Could someone give me some idea of what wrong with my code?  Thanks a lot.