【使用两个队列实现栈】_两个队列实现一个栈

---

---

前言

本文章主要介绍栈和队列的相互转换。

---

使用两个队列实现栈

我们知道，栈的特点是后进先出，而队列的特点是先进先出。

栈的特点：

队列的特点：

使用两个队列实现栈的思路是：

1.向两个队列中的任一队列放入元素
2.取出元素时，队列的功能是先进先出，要达到后进先出，需要将前面的所有元素取出，存入另一个空队列中，然后将剩下的最后一个元素释放掉即可。

比如：

后面如果想继续插入元素的话，应该将插入的元素放在非空队列中，这样就实现了栈的功能。

这样实现的原因是，两个队列中必有其中一个队列是空队列，保证了栈的后进先出的特点。

下面给出一道题目
两个队列实现栈

这里我用c语言来实现，所以先先写好队列的基本功能，再将接口函数引入。

1.队列接口函数引入

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;

		free(del);
		//del = NULL;
	}

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail == NULL;
}

// 1G = 1024MB
// 1024MB = 1024*1024KB
// 1024*1024KB = 1024*1024*1024Byte

int QueueSize(Queue* pq)
{
	assert(pq);

	/*int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		++size;
	}

	return size;*/

	return pq->size;
}

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

2.栈的初始化

MyStack* myStackCreate() {
    MyStack*st = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->q1);
    QueueInit(&st->q2);
    return st;
}
1
2
3
4
5
6

栈的初始化就是将两个队列进行初始化。

3.向栈中插入元素

保证其中一个队列不为空
//首先需要判断哪个队列为空，可以用ifelse来判断，但是这样操作冗余的，所以可以使用假设
int myStackPop(MyStack*
void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

由于无法得知哪一个队列为空，则需要判断或者假设，使用判断的化，代码比较冗余，在这里我使用假设，假设第一个队列是空。

4.出栈操作

int myStackPop(MyStack* obj) {
    Queue*EmptyQ = &obj->q1;
    Queue*NonEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        //如果q1不为空，返回假，！就返回真，进入if
        //意思就是我们假设错误了。
        EmptyQ = &obj->q2;
        NonEmptyQ = &obj->q1;
    }
    //来到这里已经知道哪个是空了,把所有元素导入非空队列，将最后一个不导
    while(QueueSize(NonEmptyQ)>1)
    {
        QueuePush(EmptyQ,QueueFront(NonEmptyQ));
        QueuePop(NonEmptyQ);
    }
    int top = QueueFront(NonEmptyQ);
    QueuePop(NonEmptyQ);
    return top;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.取出栈顶元素

int myStackTop(MyStack* obj) {
    //取出栈顶元素
    //在首先的队列中，我们虽然不能删除队尾元素，但是我们可以取出队尾的元素
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

6.判断栈是否为空

bool myStackEmpty(MyStack* obj) 
{   
    //判断栈是否为空，需要判断两个队列是否为空
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
1
2
3
4
5

判断栈是否为空，需要判断两个队列是否为空

7.释放内存空间

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}
1
2
3
4
5

注意，由于两个队列的维护是依靠指针，所以两个队列申请的空间先释放，再释放栈结构体空间

---

总结

本文章介绍了两个队列实现栈的方法。
使用队列实现栈和使用栈实现队列都是可以的
下篇文章介绍使用两个栈实现队列