栈和队列（Java语言版）
一、栈和队列
栈和队列是线性数据结构的典型代表，数组和链表的兄弟姐妹。按照存储方式可分为顺序存储结构和链式存储结构。
1.栈（Stack）
栈只允许在有序的线性资料集合的一端（称为堆栈顶端，top）进行入栈（push）和出栈（pop）的运算，是一种后进先出（Last in First Out）的数据结构，简称 LIFO。
后进先出即最后存入的数据在取出的时候会最先被取出。举个例子，比如厨房叠在一起的碗，先放上去的碗堆在下面，取出的时候最后拿出，后放上去的碗在最上面，取出的时候最先拿出。
堆栈常用一维数组或链表来实现，即顺序存储结构与链式存储结构。
2.队列（Ｑueue）
队列是先进先出（FIFO, First-In-First-Out）的线性表。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。
队列常用一维数组或链表来实现，即顺序存储结构与链式存储结构。
队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。
二、栈的基本操作（顺序存储结构）
使用数组实现栈
0.初始化栈
由于是使用数组实现的，所以初始化栈时需设置栈的大小。
// 数组栈
public class ArrayStack {
int maxSize;
int[] list; //数组模拟栈，数据放在该数组
int top = 0; //表示栈顶，初始化为0
// 初始化栈
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
list = new int[maxSize];
}
}
1.入栈操作
将要入栈的值存入数组中，同时指针top上移。
如果栈已经满了，则添加失败。
可以在栈满后创建一个更大的数组来优化操作
// 入栈操作
public void push(int val) {
if (top >= maxSize) {
System.out.println("The stack is max!");
} else {
list[top] = val;
top++;
}
}
2.出栈操作
top指针直接下移即可。
public void pop() {
if (top == 0) {
System.out.println("Error! The stack is empty!");
} else {
top--;
}
}
3. 打印栈
输出栈中的元素。
public void display() {
if(top == 0){
System.out.println("The stack is empty!");
return;
}
for(int i = 0; i < top; i++) {
System.out.print(list[i]+" ");
}
System.out.println();
}
4.清空栈
top指针置于起点即可。
public void clear() {
top = 0;
}
5.判空
public boolean isEmpty() {
if (top == 0) {
return true;
} else {
return false;
}
}
6.返回栈顶元素
public Object peek() {
if (top != 0) {
return list[top-1];
} else {
return null;
}
}
7.全部整合代码（包括测试）
// 数组栈
public class ArrayStack {
int maxSize;
int[] list; //数组模拟栈，数据放在该数组
int top = 0; //表示栈顶，初始化为0
// 初始化栈
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
list = new int[maxSize];
}
// 入栈操作
public void push(int val) {
if (top >= maxSize) {
System.out.println("The stack is max!");
} else {
list[top] = val;
top++;
}
}
// 出栈操作
public void pop() {
if (top == 0) {
System.out.println("Error! The stack is empty!");
} else {
top--;
}
}
// 打印栈
public void display() {
if(top == 0){
System.out.println("The stack is empty!");
return;
}
for(int i = 0; i < top; i++) {
System.out.print(list[i]+" ");
}
System.out.println();
}
// 清空栈
public void clear() {
top = 0;
}
// 判空
public boolean isEmpty() {
if (top == 0) {
return true;
} else {
return false;
}
}
// 返回栈顶元素
public Object peek() {
if (top != 0) {
return list[top-1];
} else {
return null;
}
}
public static void main(String[] args) {
ArrayStack arrayStack = new ArrayStack(5);
System.out.println(arrayStack.isEmpty());
arrayStack.push(1);
arrayStack.push(2);
arrayStack.push(3);
arrayStack.push(4);
arrayStack.display();
arrayStack.pop();
arrayStack.display();
arrayStack.push(5);
arrayStack.display();
System.out.println(arrayStack.peek());
System.out.println(arrayStack.isEmpty());
arrayStack.clear();
arrayStack.display();
System.out.println(arrayStack.peek());
System.out.println(arrayStack.isEmpty());
}
}
三、栈的基本操作（链式存储结构）
使用链表实现栈
0.初始化栈
创建StackNode类，每个StackNode对象表示一个节点。
// 链栈
public class LinkStack{
// 链栈的结点构造
class StackNode{
int val; // 每个节点存放的值
StackNode next; // 指向下一个节点
StackNode() {
}
StackNode(int val) {
this.val = val;
}
StackNode(int val, StackNode next) {
this.val = val;
this.next = next;
}
}
int size = 0;
StackNode topNode;
}
1.入栈操作
即把元素插入栈顶，和头插法相同
// 入栈操作
public void push (int val) {
StackNode newStackNode = new StackNode();
newStackNode.val = val;
if (topNode == null) {
topNode = newStackNode;
size ++;
} else {
newStackNode.next = topNode;
topNode = newStackNode;
size ++;
}
System.out.println(val + " has been stacked!");
}
2.出栈操作
top指针直接下移即可。
public void pop() {
if (topNode == null) {
System.out.println("Error! The stack is empty!");
} else {
int popValue = topNode.val; // 接收一下出栈的元素，方便后面打印出来
topNode = topNode.next; // 栈顶指针（即链表头结点）直接指向下一个元素即可删除
size--;
System.out.println(popValue + " is out of stack!");
}
}
3. 打印栈
输出栈中的元素。
public void display() {
StackNode current = topNode;
while(current != null){
System.out.print(current.val);
if (current.next != null) {
System.out.print(" ");
}
current = current.next;
}
System.out.println();
}
4.清空栈
清空topNode。
public void clear() {
if(topNode == null) {
System.out.println("The stack is empty!");
} else {
topNode = null;
System.out.println("Stack has been emptied!");
}
}
5.判空
public boolean isEmpty() {
if (topNode == null) {
return true;
} else {
return false;
}
}
6.返回栈顶元素
public int peek() {
if(topNode == null) {
System.out.println("The stack is empty!");
}
return topNode.val;
}
7.全部整合代码（包括测试）
// 链栈
public class LinkStack {
// 链栈的结点构造
class StackNode{
int val; // 每个节点存放的值
StackNode next; // 指向下一个节点
StackNode() {
}
StackNode(int val) {
this.val = val;
}
StackNode(int val, StackNode next) {
this.val = val;
this.next = next;
}
}
int size = 0;
StackNode topNode;
// 入栈操作！即把元素插入栈顶，和头插法相同
public void push (int val) {
StackNode newStackNode = new StackNode();
newStackNode.val = val;
if (topNode == null) {
topNode = newStackNode;
size ++;
} else {
newStackNode.next = topNode;
topNode = newStackNode;
size ++;
}
System.out.println(val + " has been stacked!");
}
// 出栈操作！
public void pop () {
if (topNode == null) {
System.out.println("Error! The stack is empty!");
} else {
int popValue = topNode.val; // 接收一下出栈的元素，方便后面打印出来
topNode = topNode.next; // 栈顶指针（即链表头结点）直接指向下一个元素即可删除
size--;
System.out.println(popValue + " is out of stack!");
}
}
public void display () {
StackNode current = topNode;
while(current != null){
System.out.print(current.val);
if (current.next != null) {
System.out.print(" ");
}
current = current.next;
}
System.out.println();
}
public int peek() {
if(topNode == null) {
System.out.println("The stack is empty!");
}
return topNode.val;
}
public void clear () {
if(topNode == null) {
System.out.println("The stack is empty!");
} else {
topNode = null;
System.out.println("Stack has been emptied!");
}
}
public boolean isEmpty () {
if (topNode == null) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
LinkStack linkStack = new LinkStack();
linkStack.push(2);
linkStack.push(3);
linkStack.display();
linkStack.pop();
linkStack.display();
System.out.println("The topNode is "+linkStack.peek());
linkStack.clear();
System.out.println("The stack is null? "+linkStack.isEmpty());
linkStack.push(8);
linkStack.push(7);
linkStack.push(5);
linkStack.display();
System.out.println("The stack is null? "+linkStack.isEmpty());
}
}
四、队列的基本操作 （顺序存储结构）
使用数组实现队列
0.初始化队列
public class ArrayQueue {
int maxSize; // 队列最大容量
int[] list; //数组模拟队列，数据放在该数组
int front = 0; //队头指针front，指向队头元素
int rear = 0; //队尾指针rear，指向下一个入队元素的存储位置
int currentSize; // 记录当前队列有几个元素
// 初始化队列
public ArrayQueue(int maxSize) {
this.maxSize = maxSize;
list = new int[maxSize];
front = 0;
rear = 0;
currentSize = 0;
}
}
1.入队操作
将要入队的值存入数组中，同时队尾指针rear后移。
如果队列已经满了，则添加失败。
可以在队列满后创建一个更大的数组来优化操作
// 入队
public void enQueue (int val) {
if (currentSize >= maxSize) {
System.out.println("Error! The queue is full!");
} else {
list[rear % maxSize] = val;
rear ++;
currentSize ++;
System.out.println(val + " has been queued!");
}
}
2.出队操作
队头指针front后移
public void deQueue () {
if (currentSize == 0) {
System.out.println("Error! The queue is empty!");
} else {
int dequeueValue = list[front];
front = (front + 1) % maxSize;
currentSize --;
System.out.println(dequeueValue + " is dequeued!");
}
}
3. 打印队列
输出队列中的元素。
public void display() {
if(rear == front){
System.out.println("The queue is empty!");
return;
}
for(int i = front; i < rear; i++) {
System.out.print(list[i % maxSize]+" ");
}
System.out.println();
}
4.完整整合代码（包含测试）
package queue;
// 队列
public class ArrayQueue {
int maxSize; // 队列最大容量
int[] list; //数组模拟队列，数据放在该数组
int front = 0; //队头指针front，指向队头元素
int rear = 0; //队尾指针rear，指向下一个入队元素的存储位置
int currentSize; // 记录当前队列有几个元素
// 初始化队列
public ArrayQueue(int maxSize) {
this.maxSize = maxSize;
list = new int[maxSize];
front = 0;
rear = 0;
currentSize = 0;
}
// 入队
public void enQueue (int val) {
if (currentSize >= maxSize) {
System.out.println("Error! The queue is full!");
} else {
list[rear % maxSize] = val;
rear ++;
currentSize ++;
System.out.println(val + " has been queued!");
}
}
// 出队
public void deQueue () {
if (currentSize == 0) {
System.out.println("Error! The queue is empty!");
} else {
int dequeueValue = list[front];
front = (front + 1) % maxSize;
currentSize --;
System.out.println(dequeueValue + " is dequeued!");
}
}
public void display () {
if(rear == front){
System.out.println("The queue is empty!");
return;
}
for(int i = front; i < rear; i++) {
System.out.print(list[i % maxSize]+" ");
}
System.out.println();
}
public static void main(String[] args) {
ArrayQueue arrayQueue = new ArrayQueue(9);
arrayQueue.enQueue(1);
arrayQueue.enQueue(2);
arrayQueue.enQueue(3);
arrayQueue.enQueue(4);
arrayQueue.enQueue(5);
arrayQueue.enQueue(6);
arrayQueue.enQueue(7);
arrayQueue.enQueue(8);
arrayQueue.enQueue(9);
arrayQueue.display();
arrayQueue.deQueue();
arrayQueue.enQueue(1);
arrayQueue.display();
}
}
五、队列的基本操作 （链式存储结构）
使用链表实现队列
0.初始化队列
创建QueueNode对象表示队列节点。声明队头指针和队尾指针。
// 链式队列
public class LinkQueue {
// 链式队列的结点构造
static class QueueNode{
int val;
QueueNode next;
// 初始化栈
QueueNode() {
}
QueueNode(int val) {
this.val = val;
}
QueueNode(int val, QueueNode next) {
this.val = val;
this.next = next;
}
}
int size = 0; // 记录当前队列有几个元素
QueueNode front; // 队头指针front，指向队头元素
QueueNode rear; // 队尾指针rear，指向下一个入队元素的存储位置
QueueNode back; // 队尾指针back，指向队尾元素
}
1.入队操作
将要入队的值存入QueueNode 对象中，同时队尾指针后移。
// 入队
public void enQueue (int val) {
QueueNode queueNode = new QueueNode();
queueNode.val = val;
if (front == null) {
front = queueNode;
back = queueNode;
System.out.println(val + " has been queued!");
size ++;
} else {
back.next = queueNode;
back = back.next;
System.out.println(val + " has been queued!");
size ++;
}
}
2.出队操作
队头指针front后移
public void deQueue () {
if (front == null) {
System.out.println("Error! The queue is empty!");
} else {
front = front.next;
}
}
3. 打印队列
输出队列中的元素。
public void display () {
QueueNode current = front;
while(current != null){
System.out.print(current.val);
if (current.next != null) {
System.out.print(" ");
}
current = current.next;
}
System.out.println();
}
4.完整整合代码（包含测试）
package queue;
// 链式队列
public class LinkQueue {
// 链式队列的结点构造
static class QueueNode{
int val;
QueueNode next;
// 初始化栈
QueueNode() {
}
QueueNode(int val) {
this.val = val;
}
QueueNode(int val, QueueNode next) {
this.val = val;
this.next = next;
}
}
int size = 0; // 记录当前队列有几个元素
QueueNode front; // 队头指针front，指向队头元素
QueueNode rear; // 队尾指针rear，指向下一个入队元素的存储位置
QueueNode back; // 队尾指针back，指向队尾元素
public void enQueue(int val) {
QueueNode queueNode = new QueueNode();
queueNode.val = val;
if (front == null) {
front = queueNode;
back = queueNode;
System.out.println(val + " has been queued!");
size ++;
} else {
back.next = queueNode;
back = back.next;
System.out.println(val + " has been queued!");
size ++;
}
}
public void deQueue() {
if (front == null) {
System.out.println("Error! The queue is empty!");
} else {
front = front.next;
}
}
public void display () {
QueueNode current = front;
while(current != null){
System.out.print(current.val);
if (current.next != null) {
System.out.print(" ");
}
current = current.next;
}
System.out.println();
}
public static void main(String[] args) {
LinkQueue linkQueue = new LinkQueue();
linkQueue.enQueue(1);
linkQueue.enQueue(2);
linkQueue.enQueue(3);
linkQueue.enQueue(4);
linkQueue.display();
linkQueue.deQueue();
linkQueue.display();
}
}