Example001
题目
请利用两个栈 s1 和 s2 来模拟一个队列，假设栈中元素为 int 型，栈中元素最多为 maxSize。已知栈的 3 个运算定义如下：
push(ST, x)：元素 x 入 ST 栈。pop(ST, &x)：ST 栈顶元素出栈，赋给变量 x。isEmpty(ST)：判断 ST 栈是否为空。
如何利用栈的运算来实现该队列的 3 个运算：enQueue（元素入队列）、deQueue（元素出队列）、isQueueEmpty（判断队列是否为空，空返回 1，不空返回 0）。
分析
利用两个栈 S1 和 S2 来模拟一个队列，当需要向队列中插入一个元素时，用栈 S1 来存放入队的元素，即 S1 执行入栈操作。当需要出队时，则对栈 S2 执行出栈操作。由于从栈中取出元素的顺序是原顺序的逆序，所以必须先将 S1 中的所有元素全部出栈并压入到 S2 栈中，再在 S2 中执行出栈操作，即可实现出队操作，而在执行此操作前必须判断 S2 是否为空，否则会导致顺序混乱。当 S1 和 S2 都为空时队列才为空。
之前也写过这题，可以参考：考研数据结构之队列（3.3）——练习题之利用两个栈s1和s2来模拟一个队列，然后利用栈的运算来实现队列的enQueue、deQueue及isQueueEmpty运算（C表示）。
图解
- 空队列
- 非空队列
- 入队
- 出队
C实现
核心代码：
/**
* 将元素入队
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @param ele 待入队元素
* @return 如果入队成功则返回 1，否则返回 0 表示入队失败
*/
int enQueue(SeqStack *s1, SeqStack *s2, int ele) {
// 1.根据栈 s1 是否满来操作
// 1.1 如果栈 s1 是未满状态，那么可以一直直接将元素压入 s1 中，即使有待出队的元素也是在 s2 中，s1 毫无影响
if (s1->top != MAXSIZE - 1) {
push(s1, ele);
}
// 1.2 如果栈 s1 是已满状态，那说明栈 s1 已经放不下新元素了，那么可以将这些元素全部转移到栈 s2 中，转移之后，栈 s1 又能继续入队新元素了
else {
// 1.2.1 在栈 s1 已满的情况下，如果栈 s2 是非空，则不能入栈
// 但是将 s1 中的全部元素转移到 s2 中有一个问题，即要求 s2 是空栈才能转移
// 如果栈 s2 不是空栈，那么就不能将栈 s1 中的元素入栈，因为会影响原栈 s2 中的元素出队，会打乱队列先进先出的特性
if (!isEmpty(*s2)) {
return 0;
}
// 1.2.2 如果栈 s2 是空栈，那么就将栈 s1 中所有元素压入栈 s2 中
else {
// 1.2.2.1 将 s1 中所有元素压入栈 s2 中
while (!isEmpty(*s1)) {
// 局部变量，存储从栈 s1 出栈的栈顶元素
int top;
// 将栈 s1 的栈顶元素出栈
pop(s1, &top);
// 将刚才 s1 出出栈的栈顶元素压入栈 s2 中
push(s2, top);
}
// 1.2.2.2 然后再将新元素压入栈 s1 中
push(s1, ele);
}
}
return 1;
}
/**
* 将元素出队
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @param ele 用来保存出队的元素
* @return 如果入队成功则返回 1，否则返回 0 表示入队失败
*/
int deQueue(SeqStack *s1, SeqStack *s2, int *ele) {
// 局部变量，用来存储栈顶元素
int top;
// 1.根据栈 s2 是否为空来进行操作
// 1.1 如果栈 s2 非空，那么直接将栈 s2 的栈顶元素出栈即可
if (!isEmpty(*s2)) {
pop(s2, &top);
*ele = top;
}
// 1.2 如果栈 s2 为空，那么就需要检查下栈 s1 是否有已经入队的元素，如果 s1 中有元素，那么将 s1 中的所有元素压入栈 s2 中，然后将栈 s2 的栈顶元素出栈；如果 s1 中没有元素，则不能出队
else {
// 1.2.1 如果栈 s1 也为空，则没有元素可以出队，则返回 0 表示出队失败
if (isEmpty(*s1)) {
return 0;
}
// 1.2.2 如果栈 s1 非空，则将 s1 所有元素压入栈 s2 中，然后再将 s2 中的元素进行出栈
else {
// 1.2.2.1 将 s1 中的所有元素压入栈 s2 中
while (!isEmpty(*s1)) {
// 将栈 s1 的栈顶元素出栈
pop(s1, &top);
// 然后将 s1 出栈的栈顶元素压入栈 s2 中
push(s2, top);
}
// 1.2.2.2 然后将栈 s2 的栈顶元素出栈
pop(s2, &top);// 将栈 s2 的栈顶元素出栈
*ele = top;// 用 ele 保存栈 s2 的出栈元素。其实这两行代码可以写成一步：pop(s2, ele)。
}
}
return 1;
}
/**
* 判断队列是否为空
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @return 如果队列为空则返回 1，否则返回 0
*/
int isQueueEmpty(SeqStack s1, SeqStack s2) {
// 只有栈 s1 和 s2 同时为空，则才表示该队列为空
// 因为栈 s1 是用来存储入队元素的，而栈 s2 用来存储出队元素的，所以只要有一个不为空，那么则表示队列不为空
if (isEmpty(s1) && isEmpty(s2)) {
return 1;
} else {
return 0;
}
}
完整代码：
#include<stdio.h>
/**
* 顺序栈最大存储的元素个数
*/
#define MAXSIZE 5
/**
* 顺序栈结构体定义
*/
typedef struct {
/**
* 数据域，数组，用来存储栈中元素
*/
int data[MAXSIZE];
/**
* 指针域，表示栈顶指针，实际上就是数组下标
*/
int top;
} SeqStack;
/**
* 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
* @param stack 顺序栈
*/
void init(SeqStack *stack) {
// 设定让栈顶指针指向 -1 表示为栈空
stack->top = -1;
}
/**
* 判断顺序栈是否为空
* @param stack 顺序栈
* @return 如果顺序栈为空则返回 1，否则返回 0
*/
int isEmpty(SeqStack stack) {
// 只需要判断栈顶指针是否等于 -1 即可，如果是空栈则返回 1，不是空栈则返回 0
if (stack.top == -1) {
return 1;
} else {
return 0;
}
}
/**
* 将元素入栈
* @param stack 顺序栈
* @param ele 元素值
* @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
*/
int push(SeqStack *stack, int ele) {
// 1.参数校验，如果栈满则不能入栈元素
if (stack->top == MAXSIZE - 1) {
// 如果栈满，则返回 0，表示不能入栈
return 0;
}
// 2.先将栈顶指针加一，指向新空数组位置
stack->top++;
// 3.将新元素值填充到新位置中
stack->data[stack->top] = ele;
return 1;
}
/**
* 将元素出栈
* @param stack 顺序栈
* @param ele 用来保存出栈的元素
* @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
*/
int pop(SeqStack *stack, int *ele) {
// 1.参数校验，栈空不能出栈
if (stack->top == -1) {
// 栈空，没有元素可出栈
return 0;
}
// 2.用 ele 来保存顺序栈栈顶元素
*ele = stack->data[stack->top];
// 3.然后栈顶指针减一，表示出栈一个元素
stack->top--;
return 1;
}
/**
* 将元素入队
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @param ele 待入队元素
* @return 如果入队成功则返回 1，否则返回 0 表示入队失败
*/
int enQueue(SeqStack *s1, SeqStack *s2, int ele) {
// 1.根据栈 s1 是否满来操作
// 1.1 如果栈 s1 是未满状态，那么可以一直直接将元素压入 s1 中，即使有待出队的元素也是在 s2 中，s1 毫无影响
if (s1->top != MAXSIZE - 1) {
push(s1, ele);
}
// 1.2 如果栈 s1 是已满状态，那说明栈 s1 已经放不下新元素了，那么可以将这些元素全部转移到栈 s2 中，转移之后，栈 s1 又能继续入队新元素了
else {
// 1.2.1 在栈 s1 已满的情况下，如果栈 s2 是非空，则不能入栈
// 但是将 s1 中的全部元素转移到 s2 中有一个问题，即要求 s2 是空栈才能转移
// 如果栈 s2 不是空栈，那么就不能将栈 s1 中的元素入栈，因为会影响原栈 s2 中的元素出队，会打乱队列先进先出的特性
if (!isEmpty(*s2)) {
return 0;
}
// 1.2.2 如果栈 s2 是空栈，那么就将栈 s1 中所有元素压入栈 s2 中
else {
// 1.2.2.1 将 s1 中所有元素压入栈 s2 中
while (!isEmpty(*s1)) {
// 局部变量，存储从栈 s1 出栈的栈顶元素
int top;
// 将栈 s1 的栈顶元素出栈
pop(s1, &top);
// 将刚才 s1 出出栈的栈顶元素压入栈 s2 中
push(s2, top);
}
// 1.2.2.2 然后再将新元素压入栈 s1 中
push(s1, ele);
}
}
return 1;
}
/**
* 将元素出队
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @param ele 用来保存出队的元素
* @return 如果入队成功则返回 1，否则返回 0 表示入队失败
*/
int deQueue(SeqStack *s1, SeqStack *s2, int *ele) {
// 局部变量，用来存储栈顶元素
int top;
// 1.根据栈 s2 是否为空来进行操作
// 1.1 如果栈 s2 非空，那么直接将栈 s2 的栈顶元素出栈即可
if (!isEmpty(*s2)) {
pop(s2, &top);
*ele = top;
}
// 1.2 如果栈 s2 为空，那么就需要检查下栈 s1 是否有已经入队的元素，如果 s1 中有元素，那么将 s1 中的所有元素压入栈 s2 中，然后将栈 s2 的栈顶元素出栈；如果 s1 中没有元素，则不能出队
else {
// 1.2.1 如果栈 s1 也为空，则没有元素可以出队，则返回 0 表示出队失败
if (isEmpty(*s1)) {
return 0;
}
// 1.2.2 如果栈 s1 非空，则将 s1 所有元素压入栈 s2 中，然后再将 s2 中的元素进行出栈
else {
// 1.2.2.1 将 s1 中的所有元素压入栈 s2 中
while (!isEmpty(*s1)) {
// 将栈 s1 的栈顶元素出栈
pop(s1, &top);
// 然后将 s1 出栈的栈顶元素压入栈 s2 中
push(s2, top);
}
// 1.2.2.2 然后将栈 s2 的栈顶元素出栈
pop(s2, &top);// 将栈 s2 的栈顶元素出栈
*ele = top;// 用 ele 保存栈 s2 的出栈元素。其实这两行代码可以写成一步：pop(s2, ele)。
}
}
return 1;
}
/**
* 判断队列是否为空
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @return 如果队列为空则返回 1，否则返回 0
*/
int isQueueEmpty(SeqStack s1, SeqStack s2) {
// 只有栈 s1 和 s2 同时为空，则才表示该队列为空
// 因为栈 s1 是用来存储入队元素的，而栈 s2 用来存储出队元素的，所以只要有一个不为空，那么则表示队列不为空
if (isEmpty(s1) && isEmpty(s2)) {
return 1;
} else {
return 0;
}
}
int main() {
// 声明两个顺序栈并初始化
SeqStack s1;
init(&s1);
SeqStack s2;
init(&s2);
// 是否队空
printf("\n是否队空：\n");
int empty;
empty = isQueueEmpty(s1, s2);
printf("%d\n", empty);
// 将元素入队
enQueue(&s1, &s2, 11);
enQueue(&s1, &s2, 22);
enQueue(&s1, &s2, 33);
enQueue(&s1, &s2, 44);
enQueue(&s1, &s2, 55);
enQueue(&s1, &s2, 66);
enQueue(&s1, &s2, 77);
// 将元素出队
printf("\n将元素出队：\n");
int ele;
deQueue(&s1, &s2, &ele);
printf("出队元素：%d\n", ele);
deQueue(&s1, &s2, &ele);
printf("出队元素：%d\n", ele);
deQueue(&s1, &s2, &ele);
printf("出队元素：%d\n", ele);
deQueue(&s1, &s2, &ele);
printf("出队元素：%d\n", ele);
}
执行结果：
是否队空：
1
将元素出队：
出队元素：11
出队元素：22
出队元素：33
出队元素：44
Java实现
核心代码：
/**
* 将元素入队
*
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @param ele 待入队元素
* @throws Exception s1 已满，s2 非空不能入队则抛出该异常
*/
public static void enQueue(SeqStack s1, SeqStack s2, int ele) throws Exception {
// 1.根据栈 s1 是否满来操作
// 1.1 如果栈 s1 是未满状态，那么可以一直直接将元素压入 s1 中，即使有待出队的元素也是在 s2 中，s1 毫无影响
if (!s1.isFull()) {
s1.push(ele);
}
// 1.2 如果栈 s1 是已满状态，那说明栈 s1 已经放不下新元素了，那么可以将这些元素全部转移到栈 s2 中，转移之后，栈 s1 又能继续入队新元素了
else {
// 1.2.1 在栈 s1 已满的情况下，如果栈 s2 是非空，则不能入栈
// 但是将 s1 中的全部元素转移到 s2 中有一个问题，即要求 s2 是空栈才能转移
// 如果栈 s2 不是空栈，那么就不能将栈 s1 中的元素入栈，因为会影响原栈 s2 中的元素出队，会打乱队列先进先出的特性
if (!s2.isEmpty()) {
throw new Exception("s1 已满，s2 非空因此不能入队！");
}
// 1.2.2 如果栈 s2 是空栈，那么就将栈 s1 中所有元素压入栈 s2 中
else {
// 1.2.2.1 将 s1 中所有元素压入栈 s2 中
while (!s1.isEmpty()) {
// 将栈 s1 的栈顶元素出栈
int top = s1.pop();
// 将刚才 s1 出出栈的栈顶元素压入栈 s2 中
s2.push(top);
}
// 1.2.2.2 然后再将新元素压入栈 s1 中
s1.push(ele);
}
}
}
/**
* 将元素出队
*
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @return 用来保存出队的元素
* @throws Exception 如果栈 s1 和 s2 均为空则抛出此异常
*/
public static int deQueue(SeqStack s1, SeqStack s2) throws Exception {
// 局部变量，用来存储栈顶元素，即出队元素
int ele = 0;
// 1.根据栈 s2 是否为空来进行操作
// 1.1 如果栈 s2 非空，那么直接将栈 s2 的栈顶元素出栈即可
if (!s2.isEmpty()) {
ele = s2.pop();
}
// 1.2 如果栈 s2 为空，那么就需要检查下栈 s1 是否有已经入队的元素，如果 s1 中有元素，那么将 s1 中的所有元素压入栈 s2 中，然后将栈 s2 的栈顶元素出栈；如果 s1 中没有元素，则不能出队
else {
// 1.2.1 如果栈 s1 也为空，则没有元素可以出队，则抛出异常表示出队失败
if (s1.isEmpty()) {
throw new Exception("s1 和 s2 均为空无可出队元素！");
}
// 1.2.2 如果栈 s1 非空，则将 s1 所有元素压入栈 s2 中，然后再将 s2 中的元素进行出栈
else {
// 1.2.2.1 将 s1 中的所有元素压入栈 s2 中
while (!s1.isEmpty()) {
// 将栈 s1 的栈顶元素出栈
ele = s1.pop();
// 然后将 s1 出栈的栈顶元素压入栈 s2 中
s2.push(ele);
}
// 1.2.2.2 然后将栈 s2 的栈顶元素出栈，即出队元素
ele = s2.pop();
}
}
// 最后返回出队元素
return ele;
}
/**
* 判断队列是否为空
*
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @return 如果队列为空则返回 1，否则返回 0
*/
public static boolean isQueueEmpty(SeqStack s1, SeqStack s2) {
return s1.isEmpty() && s2.isEmpty();
}
完整代码：
public class Test {
public static void main(String[] args) throws Exception {
// 声明两个顺序栈并初始化
SeqStack s1 = new SeqStack();
s1.init();
SeqStack s2 = new SeqStack();
s2.init();
// 是否队空
System.out.println("\n是否队空：");
boolean empty;
empty = isQueueEmpty(s1, s2);
System.out.println(empty);
// 将元素入队
enQueue(s1, s2, 11);
enQueue(s1, s2, 22);
enQueue(s1, s2, 33);
enQueue(s1, s2, 44);
enQueue(s1, s2, 55);
enQueue(s1, s2, 66);
enQueue(s1, s2, 77);
// 将元素出队
System.out.println("\n将元素出队：");
int ele;
ele = deQueue(s1, s2);
System.out.println("出队元素：" + ele);
ele = deQueue(s1, s2);
System.out.println("出队元素：" + ele);
ele = deQueue(s1, s2);
System.out.println("出队元素：" + ele);
ele = deQueue(s1, s2);
System.out.println("出队元素：" + ele);
}
/**
* 将元素入队
*
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @param ele 待入队元素
* @throws Exception s1 已满，s2 非空不能入队则抛出该异常
*/
public static void enQueue(SeqStack s1, SeqStack s2, int ele) throws Exception {
// 1.根据栈 s1 是否满来操作
// 1.1 如果栈 s1 是未满状态，那么可以一直直接将元素压入 s1 中，即使有待出队的元素也是在 s2 中，s1 毫无影响
if (!s1.isFull()) {
s1.push(ele);
}
// 1.2 如果栈 s1 是已满状态，那说明栈 s1 已经放不下新元素了，那么可以将这些元素全部转移到栈 s2 中，转移之后，栈 s1 又能继续入队新元素了
else {
// 1.2.1 在栈 s1 已满的情况下，如果栈 s2 是非空，则不能入栈
// 但是将 s1 中的全部元素转移到 s2 中有一个问题，即要求 s2 是空栈才能转移
// 如果栈 s2 不是空栈，那么就不能将栈 s1 中的元素入栈，因为会影响原栈 s2 中的元素出队，会打乱队列先进先出的特性
if (!s2.isEmpty()) {
throw new Exception("s1 已满，s2 非空因此不能入队！");
}
// 1.2.2 如果栈 s2 是空栈，那么就将栈 s1 中所有元素压入栈 s2 中
else {
// 1.2.2.1 将 s1 中所有元素压入栈 s2 中
while (!s1.isEmpty()) {
// 将栈 s1 的栈顶元素出栈
int top = s1.pop();
// 将刚才 s1 出出栈的栈顶元素压入栈 s2 中
s2.push(top);
}
// 1.2.2.2 然后再将新元素压入栈 s1 中
s1.push(ele);
}
}
}
/**
* 将元素出队
*
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @return 用来保存出队的元素
* @throws Exception 如果栈 s1 和 s2 均为空则抛出此异常
*/
public static int deQueue(SeqStack s1, SeqStack s2) throws Exception {
// 局部变量，用来存储栈顶元素，即出队元素
int ele = 0;
// 1.根据栈 s2 是否为空来进行操作
// 1.1 如果栈 s2 非空，那么直接将栈 s2 的栈顶元素出栈即可
if (!s2.isEmpty()) {
ele = s2.pop();
}
// 1.2 如果栈 s2 为空，那么就需要检查下栈 s1 是否有已经入队的元素，如果 s1 中有元素，那么将 s1 中的所有元素压入栈 s2 中，然后将栈 s2 的栈顶元素出栈；如果 s1 中没有元素，则不能出队
else {
// 1.2.1 如果栈 s1 也为空，则没有元素可以出队，则抛出异常表示出队失败
if (s1.isEmpty()) {
throw new Exception("s1 和 s2 均为空无可出队元素！");
}
// 1.2.2 如果栈 s1 非空，则将 s1 所有元素压入栈 s2 中，然后再将 s2 中的元素进行出栈
else {
// 1.2.2.1 将 s1 中的所有元素压入栈 s2 中
while (!s1.isEmpty()) {
// 将栈 s1 的栈顶元素出栈
ele = s1.pop();
// 然后将 s1 出栈的栈顶元素压入栈 s2 中
s2.push(ele);
}
// 1.2.2.2 然后将栈 s2 的栈顶元素出栈，即出队元素
ele = s2.pop();
}
}
// 最后返回出队元素
return ele;
}
/**
* 判断队列是否为空
*
* @param s1 一号栈，存入入队元素
* @param s2 二号栈，存储待出队元素
* @return 如果队列为空则返回 1，否则返回 0
*/
public static boolean isQueueEmpty(SeqStack s1, SeqStack s2) {
return s1.isEmpty() && s2.isEmpty();
}
}
SeqStack：
public class SeqStack {
/**
* 常量，顺序栈所能容纳的最大元素个数
*/
private final int MAXSIZE = 5;
/**
* 声明一个顺序栈
*/
private Stack stack;
/**
* 初始化顺序栈
*/
public void init() {
// 实例化栈对象
stack = new Stack();
// 为数据域分配空间
stack.data = new int[MAXSIZE];
// 将顺序栈的栈顶指针指向 -1 表示空栈
stack.top = -1;
}
/**
* 判断顺序栈是否为空
*
* @return 如果顺序栈为空则返回 true，否则返回 false
*/
public boolean isEmpty() {
// 规定了 -1 表示空栈，所以只需要判断栈顶指针是否等于 -1 即可
return stack.top == -1;
}
/**
* 判断顺序栈是否满
*
* @return 如果顺序栈已满则返回 true，否则返回 false
*/
public boolean isFull() {
// 因为栈顶指针 top 存储的是数组下标，所以判断是否等于 MAXSIZE-1
return stack.top == MAXSIZE - 1;
}
/**
* 将指定元素入栈
*
* @param ele 指定元素
* @throws Exception 如果栈满则不能入栈，抛出此异常
*/
public void push(int ele) throws Exception {
// 1.参数校验，如果栈满则不能入栈，抛出异常
if (stack.top == MAXSIZE - 1) {// 因为栈顶指针 top 存储的是数组下标，所以判断是否等于 MAXSIZE-1
throw new Exception("栈已满，不能再插入！");
}
// 2.先栈顶指针加 1，因为原栈顶指针处已经存储了元素，所以加一指向新的空位置
stack.top++;
// 3.在新的空位置处插入新元素，即为指定下标的数组元素赋值
stack.data[stack.top] = ele;
}
/**
* 将栈顶元素出栈
*
* @return 栈顶元素
* @throws Exception 如果栈空则不能出栈，抛出此异常
*/
public int pop() throws Exception {
// 1.参数校验，如果栈空则不能出栈，抛出异常
if (stack.top == -1) {// 因为栈空的定义是栈顶指针为 -1，所以如果栈顶指针为 -1 那么就是空栈，就不能出栈元素
throw new Exception("栈为空，不能出栈元素！");
}
// 2.记录栈顶元素，因为要将该元素返回，即要出栈的元素
int result = stack.data[stack.top];
// 3.栈顶指针减一，因为原栈顶元素已经出栈了，栈中元素个数减一
stack.top--;
return result;
}
/**
* 获取栈顶元素，但不出栈
*
* @return 栈顶元素
* @throws Exception 如果栈空则不能出栈，抛出此异常
*/
public int getTop() throws Exception {
// 1.参数校验，如果栈空则不能出栈，抛出异常
if (stack.top == -1) {
throw new Exception("栈为空，不能获取栈顶元素！");
}
// 2.直接返回栈顶元素，但不出栈
return stack.data[stack.top];
}
/**
* 顺序栈中元素个数
*
* @return 栈中元素个数
*/
public int size() {
// top 表示栈顶指针，实际上就是数组 data 的下标，所以实际元素个数就是下标加一
// 即使是空栈 top=-1，那么最后也会返回 0 表示元素个数为零个
return stack.top + 1;
}
/**
* 打印顺序栈中所有元素，从栈顶到栈底
*/
public void print() {
System.out.print("[");
for (int i = stack.top; i >= 0; i--) {
if (i != stack.top) {
System.out.print(", ");
}
System.out.print(stack.data[i]);
}
System.out.print("]\n");
}
/**
* 清空顺序栈
*/
public void clear() {
// 直接将栈顶指针指向 -1 即可表示空栈，不用重置栈中已有元素的值，因为顺序栈操作只跟栈顶指针有关
stack.top = -1;
}
}
/**
* 栈定义
*/
class Stack {
/**
* 顺序栈用来存储元素的数组
*/
int[] data;
/**
* 记录顺序栈的栈顶指针，即数组下标
*/
int top;
}
执行结果：
是否队空：
true
将元素出队：
出队元素：11
出队元素：22
出队元素：33
出队元素：44
