.栈和队列
(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);
}