leetcode关于微信读书的笔记-栈和队列

.栈和队列
（1）设计一个有getMin功能的栈
要求：实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作
思路：①一个栈用于储存正常的数据，一个用于存比较最小值的栈，循环对比，若新传入的值大于stackmin的栈顶元素就同时存入两个栈
②一个栈用于储存正常的数据，一个用于存比较最小值的栈，循环对比，若新传值小于stackmin的栈顶元素，将改元素压入两个栈；
若等于新传值等于stackmin的栈顶元素，栈顶元素也压入两个栈；若新传值大于stackmin的栈顶元素，将元素压入stackmain主栈,stackmin的栈顶元素再压入一遍
总结：区别是：方案一中stackMin压入时稍省空间，但是弹出操作稍费时间；方案二中stackMin压入时稍费空间，但是弹出操作稍省时间。

#define N 10000
//定义栈的结构
typedef struct {
    int *Stack;//存放所有数据的栈
    int *minStack;//存放最小值的栈
    int top_Stack;//
    
    int min_Stack;//
} MinStack;



MinStack* minStackCreate() {
    MinStack *obj=(MinStack*)malloc(sizeof(MinStack));//在堆上申请空间
    obj->Stack=(int*)malloc(sizeof(int)*N);//初始化栈并分配空间
    obj->minStack=(int*)malloc(sizeof(int)*N);
    obj->min_Stack=obj->top_Stack=-1;//指针初始化栈底为-1
    return obj;
}

void minStackPush(MinStack* obj, int x) {
    if(obj->top_Stack<N){//在栈的内存范围内
        obj->Stack[++obj->top_Stack]=x;//普通栈存所有元素
        if(obj->min_Stack==-1){//若是存最小元素的栈为空，则存入第一个元素
            obj->minStack[++obj->min_Stack]=x;
        }
        else if(x<=obj->minStack[obj->min_Stack]){//比minStack栈顶元素小才存入栈中
            obj->minStack[++obj->min_Stack]=x;
        }
    }
}

void minStackPop(MinStack* obj) {
    if(obj->Stack[obj->top_Stack]==obj->minStack[obj->min_Stack]){//若两个栈顶元素相同，则都出栈
        obj->top_Stack--;
        obj->min_Stack--;
    }
    else{
        obj->top_Stack--;
    }
}

int minStackTop(MinStack* obj) {
    return obj->Stack[obj->top_Stack];
}

int minStackMin(MinStack* obj) {
    return obj->minStack[obj->min_Stack];
}

void minStackFree(MinStack* obj) {
    free(obj->Stack);
    free(obj->minStack);
    free(obj);
}

(2)用栈实现队列
思路：
①具体实现时是一个栈作为压入栈，在压入数据时只往这个栈中压入，记为stackPush；
②另一个栈只作为弹出栈，在弹出数据时只从这个栈弹出，记为stackPop。
注意：
1.如果stackPush要往stackPop中压入数据，那么必须一次性把stackPush中的数据全部压入。
2.如果stackPop(2)不为空，stackPush(1)绝对不能向stackPop(2)中压入数据。违反了以上两点都会发生错误。
代码：

typedef struct {//定义栈的结构
    int* stk;
    int stkSize;//用来计算栈的大小
    int stkCapacity;//定义栈的大小
} Stack;

Stack* stackCreate(int cpacity) {//创建栈
    Stack* ret = malloc(sizeof(Stack));
    ret->stk = malloc(sizeof(int) * cpacity);//给栈分配空间
    ret->stkSize = 0;//用来计算栈的大小
    ret->stkCapacity = cpacity;//定义栈的容量
    return ret;
}

void stackPush(Stack* obj, int x) {
    obj->stk[obj->stkSize++] = x;//压栈
}

void stackPop(Stack* obj) {
    obj->stkSize--;//弹栈
}

int stackTop(Stack* obj) {
    return obj->stk[obj->stkSize - 1];//返回栈顶的值
}

bool stackEmpty(Stack* obj) {
    return obj->stkSize == 0;//判断栈是否为空
}

void stackFree(Stack* obj) {
    free(obj->stk);//释放栈
}

typedef struct {//定义两个栈
    Stack* inStack;//栈一专门压栈
    Stack* outStack;//栈二专门弹栈	
} MyQueue;

MyQueue* myQueueCreate() {//定义队列的结构
    MyQueue* ret = malloc(sizeof(MyQueue));
    ret->inStack = stackCreate(100);
    ret->outStack = stackCreate(100);
    return ret;
}

void in2out(MyQueue* obj) {
    while (!stackEmpty(obj->inStack)) {//当栈1不为空,把栈1数据全压栈2
        stackPush(obj->outStack, stackTop(obj->inStack));//将栈一的栈顶数据压入栈二
        stackPop(obj->inStack);//将栈一的值弹出来
    }
}

void myQueuePush(MyQueue* obj, int x) {
    stackPush(obj->inStack, x);//将x压入栈一
}

int myQueuePop(MyQueue* obj) {
    if (stackEmpty(obj->outStack)) {//若栈2为空，则把栈1的数据放到栈2
        in2out(obj);
    }
    int x = stackTop(obj->outStack);
    stackPop(obj->outStack);
    return x;//返回栈二的栈顶的数值
}

int myQueuePeek(MyQueue* obj) {
    if (stackEmpty(obj->outStack)) {
        in2out(obj);
    }
    return stackTop(obj->outStack);//找到但不移除此列表的头(第一个元素)
}

bool myQueueEmpty(MyQueue* obj) {//判断两个栈是否为空
    return stackEmpty(obj->inStack) && stackEmpty(obj->outStack);
}

void myQueueFree(MyQueue* obj) {//释放两个栈
    stackFree(obj->inStack);
    stackFree(obj->outStack);
}