day 10 第五章 栈与队列 今日任务： ● 理论基础 ● 232.用栈实现队列 ● 225. 用队列实现栈

day 10 第五章 栈与队列

今日任务：
● 理论基础
● 232.用栈实现队列
● 225. 用队列实现栈

232.用栈实现队列

typedef struct{
    int *stk;
    int stkSize;
    int stkCapacity;

}Stack;
Stack *stackCreate(int capacity){
    Stack* ret =malloc(sizeof(Stack));
    ret->stk=malloc(sizeof(int)*capacity);
    ret->stkSize=0;
    ret->stkCapacity=capacity;
    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* queue=malloc(sizeof(MyQueue));
queue->inStack=stackCreate(10);
queue->outStack=stackCreate(10);
return queue;
}

void in2out(MyQueue* obj){
    while (!stackEmpty(obj->inStack))
    {
     stackPush(obj->outStack,stackTop(obj->inStack));
     stackPop(obj->inStack);
    }
    
}
void myQueuePush(MyQueue* obj, int x) {
stackPush(obj->inStack,x);
}

int myQueuePop(MyQueue* obj) {
    if (stackEmpty(obj->outStack))
    {
    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);
}

225. 用队列实现栈

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

#define maxStackNum	100	
typedef struct {
    int* data;
	int head;	
	int rear;
} MyStack;


MyStack* myStackCreate() {
 MyStack* stack = (MyStack*)malloc(sizeof(MyStack));	
	stack->data = (int*)malloc(sizeof(int) *           maxStackNum);
	stack->head = 0;	
	stack->rear = 0;
	return stack;
}

void myStackPush(MyStack* obj, int x) {
    int curRear=obj->rear;
    if((obj->rear+1)%maxStackNum==obj->head)
        return;
    obj->data[obj->rear]=x;
    obj->rear=(obj->rear+1)%maxStackNum;
    while(obj->head!=curRear){
        obj->data[obj->rear]=obj->data[obj->head];
        obj->head=(obj->head+1)%maxStackNum;
        obj->rear=(obj->rear+1)%maxStackNum;
    }
}

int myStackPop(MyStack* obj) {
    if(obj->head==obj->rear)	//栈空
		return NULL;
     int temp=obj->head;
     obj->head=(obj->head+1)%maxStackNum;
    return obj->data[temp];
}

int myStackTop(MyStack* obj) {
    if(obj->head == obj->rear)	//栈空
		return NULL;
 return obj->data[obj->head];
}

bool myStackEmpty(MyStack* obj) {
 return obj->rear==obj->head;
}

void myStackFree(MyStack* obj) {
    free(obj->data);
	free(obj);
}

这两道题虽然在平常的生产实践中应该不会这么做，但是对于锻炼站和队列的使用还是很有帮助的。尤其是实现用一个队列实战的效果。没听过讲解，不仔细思考，或许真的很难想出来。