思路

这个就比用队列实现栈简单了

需要两个栈,一个用来接收,一个用来弹出,当弹出栈有东西时,优先弹出,当弹出栈空时,再把接受栈的给弹出栈

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#define LEN 20
typedef struct{
    int* data;
    int top;
    int size;
}Stack;

typedef struct {
    Stack* stack1,*stack2;
} MyQueue;

Stack* initStack(int k){
    Stack*obj=(Stack*)malloc(sizeof(Stack));
    obj->data=(int*)malloc(k*sizeof(int));
    obj->top=-1;
    obj->size=k;
    return obj;
}

void enStack(Stack* obj,int e){
        obj->data[++(obj->top)]=e;
}

int deStack(Stack* obj){
    int a=obj->data[(obj->top)--];
    return a;
}

bool issEmpty(Stack* obj){
    return obj->top==-1;
}

MyQueue* myQueueCreate() {
    MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
    obj->stack1=initStack(LEN);
    obj->stack2=initStack(LEN);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
        enStack(obj->stack1,x);
}

int myQueuePop(MyQueue* obj) {
    if (issEmpty(obj->stack2)) {
        while (!issEmpty(obj->stack1)) {
            enStack(obj->stack2, deStack(obj->stack1));
        }
    }
    return deStack(obj->stack2);
}

int myQueuePeek(MyQueue* obj) {
    if (issEmpty(obj->stack2)) {
        while (!issEmpty(obj->stack1)) {
            enStack(obj->stack2, deStack(obj->stack1));
        }
    }
    return obj->stack2->data[obj->stack2->top];
}

bool myQueueEmpty(MyQueue* obj) {
    if (issEmpty(obj->stack1) && issEmpty(obj->stack2)) {
        return true;
    }
    else{
        return false;
    }
}

void myQueueFree(MyQueue* obj) {
    free(obj->stack1->data);
    obj->stack1->data=NULL;
    free(obj->stack1);
    obj->stack1=NULL;
    free(obj->stack2->data);
    obj->stack2->data=NULL;
    free(obj->stack2);
    obj->stack2=NULL;
    free(obj);
    obj=NULL;
}