最小栈

设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) – 将元素 x 推入栈中。
pop() – 删除栈顶的元素。
top() – 获取栈顶元素。
getMin() – 检索栈中的最小元素。
示例:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.

typedef int STDatatype;
typedef struct Stack
{
	STDatatype* _a;
	int _top;//栈顶
	int _capacity;//容量
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;

}

void StackPush(Stack* ps, STDatatype x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDatatype*)realloc(ps->_a, sizeof(STDatatype)*newcapacity);
		assert(ps->_a);
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = x;
	ps->_top++;
}
void StackPop(Stack* ps)
{
	assert(ps);
    if(ps->_top > 0)
    {
        	ps->_top--;
    }
}
STDatatype StackTop(Stack* ps)
{
	assert(ps);
	return ps->_a[ps->_top - 1];
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 0 : 1;
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
typedef struct {
    Stack st;
    Stack minst;   
} MinStack;

/** initialize your data structure here. */
MinStack* minStackCreate(int maxSize) {
    MinStack* pst= (MinStack*)malloc(sizeof(MinStack));
    StackInit(&pst->st);
    StackInit(&pst->minst);
    return pst;
}

void minStackPush(MinStack* obj, int x) {
    if(StackEmpty(&obj->minst) == 0 || x <= StackTop(&obj->minst))
    {
        StackPush(&obj->minst,x);
    }
    StackPush(&obj->st,x);
}

void minStackPop(MinStack* obj) {
    if(StackTop(&obj->st) == StackTop(&obj->minst))
    {
        StackPop(&obj->minst);
    }
    StackPop(&obj->st);
}

int minStackTop(MinStack* obj) {
    return StackTop(&obj->st);
}

int minStackGetMin(MinStack* obj) {
    return StackTop(&obj->minst);
}

void minStackFree(MinStack* obj) {
   StackDestroy(&obj->st);
    StackDestroy(&obj->minst);
    free(obj);
}