堆栈和队列的结构
堆栈（Stack）：后进先出（LIFO-last in first out）:最后插入的元素最先出来。
队列（Queue）：先进先出（FIFO-first in first out）:最先插入的元素最先出来。
图来自网络其他博主（借鉴参考）
堆栈和队列可以由很多种方式实现，例如用数组实现堆栈，链表实现堆栈，数组实现队列，链表实现队列等，下面依次写出四种实现方式。
1.数组实现堆栈
import java.util.Scanner;
public class Stack {
private int []arr=new int [10];
private int stackTop=0;
public void push(int data) {
if(stackTop<arr.length) {
arr[stackTop++]=data;
}else
{
System.out.println("栈满了.");
}
}
public int pop() {
if(stackTop>0) {
return arr[--stackTop];
}
else System.out.println("栈空");
return -1;
}
}
public class Main {
public static void main(String[] args) {
Stack a=new Stack();
a.push(52);
a.push(5);
a.push(52);
a.push(52);
a.push(52);
a.push(52);
a.push(1584);
a.push(7841);
a.push(48);
a.push(552);
int x;
while((x=a.pop())!=-1) {
System.out.println(x);
}
}
}
结果
2.链表实现堆栈
public class Node {
Node next;
int data;
}
public class StackNodeTest {
Node root;//头节点
Node tail;//尾节点
public void push(int data) {
if(root==null) {
root=new Node();
root.data=data;
tail=root;
}else {
//创建一个新结点存进栈数据
Node a=new Node();
a.data=data;
tail.next=a;
tail=a;
}
}
public int pop() {
//无头结点
if(tail==null) {
System.out.println("栈中无数据哦");
return -Integer.MAX_VALUE;
}
//只有头节点
if(tail==root) {
int data=tail.data;
root=null;
tail=null;
return data;
}
//创建新节点遍历出需要出栈节点的上一个节点
int data=tail.data;
Node t=root;
while(t.next.next!=null) {
t=t.next;
}
//尾节点指向上一节点
tail=t;
tail.next=null;
return data;
}
public static void main (String [] args) {
StackNodeTest a=new StackNodeTest();
a.push(221);
a.push(1233333);
a.push(1233333);
System.out.println(a.pop());
System.out.println(a.pop());
System.out.println(a.pop());
System.out.println(a.pop());
a.push(221);
a.push(1233333);
System.out.println(a.pop());
a.push(234441);
System.out.println(a.pop());
System.out.println(a.pop());
System.out.println(a.pop());
}
}
结果
3.数组实现队列
注意，利用循环数组实现队列时，牺牲一个数组单元以区分队满还是队空
package lianxi;
import java.io.*;
public class QueueArray {
String[] a; //对象数组，只能存length-1个对象
int front; //队首下标
int rear; //队尾下标
public QueueArray(int size){
a = new String[size];
front = 0;
rear =0;
}
/**
* 将一个对象追加到队列尾部
* @param obj 对象
* @return 队列满时返回false,否则返回true
*/
public boolean in(String obj){
if((rear+1)%a.length==front){
return false;
}
a[rear]= obj;
rear = (rear+1)%a.length;
return true;
}
/**
* 队列头部的第一个对象出队
* @return 出队的对象，队列空时返回null
*/
public String out(){
if(rear==front){
return null;
}
String obj = a[front];
front = (front+1)%a.length;
return obj;
}
public static void main(String[] args) {
QueueArray q = new QueueArray(4);
System.out.println(q.in("aa"));
System.out.println(q.in("bb"));
System.out.println(q.in("cc"));
System.out.println(q.in("dd"));//无法入队列，队列满
for(int i=0;i<4;i++){
System.out.println(q.out());
}
}
}
结果
4.数组实现堆栈
package lianxi;
public class Stack1 {
// 堆栈容量
private int max;
// top表示栈顶
private int top = -1;
// 数组
int[] Stack;
// 创建数组
public void arrayStack(int max) {
this.max = max;
Stack = new int[this.max];
}
// 判断堆栈是否已满
public boolean isFull() {
return top == max - 1;
}
// 判断堆栈是否为空
public boolean isEmpty() {
return top == -1;
}
// 入栈
public void push(int value) {
// 判断堆栈是否已满
if (isFull()) {
System.out.println("堆栈已满！");
return;
}
// 入栈
top++;
Stack[top] = value;
}
// 出栈
public int pop() {
int value = Stack[top];
top--;
return value;
}
// 显示堆栈
public void show() {
// 判断堆栈是否为空
if (isEmpty()) {
System.out.println("堆栈为空，没有数据");
return;
}
for (int i = top; i >= 0; i--) {
System.out.println( Stack[i]);
}
}
public static void main(String[] args) {
Stack1 Stack = new Stack1();
//进栈
Stack.arrayStack(5);
Stack.push(3);
Stack.push(4);
Stack.push(5);
Stack.push(6);
Stack.show();
//出栈
System.out.println("输出的数据为:"+Stack.pop());
Stack.show();
}
}
结果：
