本文详细介绍了栈和队列的基本概念、实现方法（数组和链表），以及它们在计算表达式、计算器、算法转换中的应用，包括前缀/中缀/后缀表达式解析和逆波兰计算器。探讨了队列的普通实现和环形队列，以及如何用代码模拟。
4. 栈
4.1 基本概述
-
栈的英文为(stack)
-
栈是一个**先入后出（FIFO——First In Last Out）**的有序列表
-
栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊的线性表。允许插入和删除的一端，为变化的
一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）
-
根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶；而删除元素刚好相反，最后放入的元素最先删除，最先放入
的元素最后删除
栈的应用场景
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中
- 处理参数递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中
- 表达式的转换【中缀表达式转后缀表达式】和求值（实际解决）
- 二叉树的遍历
- 图形的深度优先（depth——first）搜索法
4.2 代码实现（数组）
public class ArrayStack {
/**
* 表示的最大容量
*/
private int maxSize;
/**
* 存储栈元素
*/
private int[] arr;
/**
* 栈顶---初始化为-1
*/
private int top;
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
top = -1;
arr = new int[maxSize];
}
/**
* 栈满
*
* @return true or false
*/
public boolean isFull() {
return top == maxSize - 1;
}
/**
* 栈空
*
* @return true or false
*/
public boolean isEmpty() {
return top == -1;
}
/**
* 入栈
*
* @param value 入栈元素
*/
public void push(int value) {
if (isFull()) {
System.out.println("栈满");
return;
}
arr[++top] = value;
}
/**
* 出栈
*
* @return 出栈元素
*/
public int pop() {
if (isEmpty()) {
// 抛出异常
throw new RuntimeException("栈空");
}
int value = arr[top];
top--;
return value;
}
/**
* 显示栈的情况，遍历时需要从栈顶开始显示数据
*/
public void list() {
if (isEmpty()) {
System.out.println("栈空，没有数据~");
return;
}
for (int i = top; i >= 0; i--) {
System.out.printf("stack【%d】 = %d\n", i, arr[i]);
}
}
}
4.3 代码实现（链表）
核心思想就是通过链表的头插法插入节点，弹出元素直接将头节点header后移一位就行，同时保留elementCount属性记录节点数和size
记录栈的大小
public class Node {
Object element;
Node next;
public Node(Object element) {
this(element, null);
}
/**
* 头插法插入节点
*
* @param element 新增节点的value
* @param n 原来的头节点
*/
public Node(Object element, Node n) {
this.element = element;
next = n;
}
public Object getElement() {
return element;
}
public void setElement(Object element) {
this.element = element;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
public class ListStack {
/**
* 栈顶元素
*/
private Node header;
/**
* 栈内元素个数
*/
private int elementCount;
/**
* 栈的大小
*/
private int size;
public ListStack() {
header = null;
elementCount = 0;
size = 0;
}
public ListStack(int size) {
header = null;
elementCount = 0;
this.size = size;
}
/**
* 设置堆栈大小
*
* @param size 堆栈大小
*/
public void setSize(int size) {
this.size = size;
}
/**
* 设置栈顶元素
*
* @param header 栈顶元素
*/
public void setHeader(Node header) {
this.header = header;
}
/**
* 获取堆栈长度
*
* @return 堆栈长度
*/
public int getSize() {
return size;
}
/**
* 返回栈中元素的个数
*
* @return 栈中元素的个数
*/
public int getElementCount() {
return elementCount;
}
/**
* 判断栈空
*
* @return true or false
*/
public boolean isEmpty() {
return elementCount == 0;
}
/**
* 判断栈满
*
* @return true or false
*/
public boolean isFull() {
return elementCount == size;
}
/**
* 把对象入栈
*
* @param value 对象
*/
public void push(Object value) {
if (isFull()) {
throw new RuntimeException("Stack is Full");
}
header = new Node(value, header);
elementCount++;
}
/**
* 出栈，并返回被出栈的元素
*
* @return 出栈的元素
*/
public Object pop() {
if (this.isEmpty()) {
throw new RuntimeException("Stack is empty");
}
Object value = header.getElement();
header = header.getNext();
elementCount--;
return value;
}
/**
* 返回栈顶元素
*
* @return 栈顶元素
*/
public Object peek() {
if (this.isEmpty()) {
throw new RuntimeException("Stack is empty");
}
return header.getElement();
}
}
4.4 栈实现计算器（中缀）
4.4.1 思路分析
-
初始化两个栈，一个【数栈】和一个【符号栈】
-
通过一个index值（索引），来遍历我们的表达式
-
如果发现是一个数字，就直接入【数栈】
-
如果发现是一个运算符，就分情况讨论
-
如果当前的【符号栈】为空，那就直接入栈
-
如果当前的【符号栈】有操作符，就进行比较
-
【当前的操作符】的优先级 <= 【符号栈中操作符】的优先级，就需要从【数栈】中pop出两个数，再从【符号栈】中pop出
一个符号，然后进行运算，将得到结果入【数栈】，再递归调用步骤3
-
【当前的操作符】的优先级 > 【符号栈中操作符】的优先级，就直接入符号栈
-
-
-
当表达式扫描完毕，就顺序的从【数栈】和【符号栈】中pop相应的数和符号，并运行
-
最从【数栈】中只有一个数字就是表达式的结果
流程图
4.4.2 代码实现
public class Calculator {
public static void main(String[] args) {
// 测试运算
String expression1 = "33+2+2*6-2";
String expression2 = "7*22*2-5+1-5+3-4";
String expression3 = "4/2*3-4*2-3-99";
String expression4 = "1*1*1*3*2/3";
String expression5 = "11*1*1*3*2/3";
String expression6 = "1000*23";
// 创建两个栈：数栈、符号栈
ListStack numStack = new ListStack(10);
ListStack operationStack = new ListStack(10);
test(expression1, numStack, operationStack);
test(expression2, numStack, operationStack);
test(expression3, numStack, operationStack);
test(expression4, numStack, operationStack);
test(expression5, numStack, operationStack);
test(expression6, numStack, operationStack);
}
/**
* 测试方法，测试表达式的结果，并且打印结果
*
* @param expression 表达式
* @param numStack 数字栈
* @param operationStack 符号栈
*/
public static void test(String expression, ListStack numStack, ListStack operationStack) {
// 用于扫描
int index = 0;
// 将每次扫描得到的char保存到ch
char ch = ' ';
// 开始while循环的扫描expression
while (true) {
// 依次得到expression的每一个字符
ch = getCharByIndex(expression, index);
// 判断ch是什么，然后做相应的处理
if (isOperation(ch)) {
// 运用管道过滤器风格，处理运算符
operationSolve1(ch, numStack, operationStack);
} else {
// 数直接入数栈，对值为ASCII值-48
// 当处理多位数时候，不能立即入栈，可能是多位数，调用过滤器处理多位数
index = numSolve1(expression, index, numStack);
}
// 让index+1，并判断是否扫描到expression最后
index++;
if (index >= expression.length()) {
break;
}
}
// 最后只剩下两个数和一个运算符
int res = cal((int) numStack.pop(), (int) numStack.pop(), (char) operationStack.pop());
System.out.printf("表达式: %s = %d\n", expression, res);
}
/**
* 符号过滤器1，判断当前是否具有字符
*
* @param ch 运算符
* @param numStack 数字栈
* @param operationStack 运算符栈
*/
private static void operationSolve1(char ch, ListStack numStack, ListStack operationStack) {
// 判断当前符号栈是否具有操作符
if (!operationStack.isEmpty()) {
// 不为空
operationSolve2(ch, numStack, operationStack);
} else {
operationStack.push(ch);
}
}
/**
* 符号过滤器2，处理字符优先级，递归调用过滤器1
*
* @param ch 运算符
* @param numStack 数字栈
* @param operationStack 运算符栈
*/
private static void operationSolve2(char ch, ListStack numStack, ListStack operationStack) {
// 比较优先级
if (priority(ch) <= priority((Character) operationStack.peek())) {
// 调用过滤器3进行计算
operationSolve3(numStack, operationStack);
// 递归调用过滤器1，不能递归调用过滤器2，因为可能存在当前运算符栈为空的情况
operationSolve1(ch, numStack, operationStack);
} else {
// 直接加入算数运算符
operationStack.push(ch);
}
}
/**
* 符号过滤器3，进行运算
*
* @param numStack 数字栈
* @param operationStack 运算符栈
*/
private static void operationSolve3(ListStack numStack, ListStack operationStack) {
int num1 = (int) numStack.pop();
int num2 = (int) numStack.pop();
char operation = (char) operationStack.pop();
int res = cal(num1, num2, operation);
// 把运算结果加到数栈
numStack.push(res);
}
/**
* 计算结果
*
* @param num1 操作数1，先出栈的数
* @param num2 操作数2，后出栈的数
* @param operation 操作符
* @return 计算结果
*/
private static int cal(int num1, int num2, char operation) {
int res = 0;
switch (operation) {
case '+' -> res = num1 + num2;
case '-' -> res = num2 - num1;
case '*' -> res = num1 * num2;
case '/' -> res = num2 / num1;
default -> System.out.println("非法运算符");
}
return res;
}
/**
* 返回运算符的优先级，数字越大，运算符越高
*
* @param operation 运算符
* @return 1 or -1 or 0
*/
private static int priority(char operation) {
if (operation == '*' || operation == '/') {
return 1;
} else if (operation == '+' || operation == '-') {
return 0;
} else {
// 假设目前的表达式只有 + - * /
return -1;
}
}
/**
* 处理数字入栈的情况，包含处理多位数的情况，并且返回到操作表达式当前的下标
*
* @param expression 表达式
* @param index 下标
* @param numStack 数字栈
* @return 操作表达式当前的下标
*/
private static int numSolve1(String expression, int index, ListStack numStack) {
// 需要对多位数进行判断
int end = index + 1;
for (; end < expression.length(); end++) {
// 判断是否为操作符
char ch = getCharByIndex(expression, end);
if (!isOperation(ch)) {
continue;
} else {
break;
}
}
// 截取多位数字---获取真正的数字
String numStr = expression.substring(index, end);
// 数据入栈
numStack.push(Integer.valueOf(numStr));
// 因为test函数进行了+1，所以这里进行-1，避免给重复添加
return end - 1;
}
/**
* 判断是不是运算符
*
* @param val 字符
* @return 是不是运算符
*/
private static boolean isOperation(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
/**
* 获取表达式的下标位置为index的字符
*
* @param expression 表达式
* @param index 下标
* @return index的字符
*/
private static char getCharByIndex(String expression, int index) {
return expression.charAt(index);
}
}
输出结果：
表达式: 33+2+2*6-2 = 45
表达式: 7*22*2-5+1-5+3-4 = 298
表达式: 4/2*3-4*2-3-99 = -104
表达式: 1*1*1*3*2/3 = 2
表达式: 11*1*1*3*2/3 = 22
表达式: 1000*23 = 23000
4.5 前缀、中缀、后缀表达式
4.5.1 前缀表达式
- 前缀表达式又称波兰表达式，前缀表达式的运算符位于操作数之前
- 举例说明：(3+4)*5-6 对应的前缀表达式就是 - * + 3 4 5 6
前缀表达式的计算机求值
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和
次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
例如 (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:
- 从右至左扫描，将6、5、4、3压入堆栈
- 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈
- 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
- 最后是-运算符，计算出35-6的值，即29，由此得出最终结果
4.5.2 中缀表达式
-
中缀表达式就是常见的运算表达式，如(3+4)*5-6
-
中缀表达式的求值是平常最为熟悉的，但是对计算机说却不好操作（前面我们将的案例就能看出这个问题，）因此，在计算结束时，
往往会将中缀表达式转成其它表达式来操作（一般是转成后缀表达式）
4.5.3 后缀表达式
- 后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后
- 举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
| 正常的表达式 | 逆波兰表达式 |
|---|---|
| a+b | a b + |
| a+(b-c) | a b c - + |
| a+(b-c)*d | a b c – d * + |
| a+d*(b-c) | a d b c - * + |
| a=1+3 | a 1 3 + = |
后缀表达式的计算机求值
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和
栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果
例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
- 从左至右扫描，将3和4压入堆栈
- 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈
- 将5入栈
- 接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈
- 将6入栈
- 最后是-运算符，计算出35-6的值，即29，由此得出最终结果
4.6 逆波兰计算器
- 输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果
- 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。
public class PolandNotation {
public static void main(String[] args) {
// 定义一个逆波兰表达式
// (3+4)*5-6 => 3 4 + 5 * 6 -
String suffixExpression = "3 4 + 5 * 6 -";
// 先将3 4 + 5 * 6 - 放入一个链表，配合栈完成计算
List<String> listString = getListString(suffixExpression);
System.out.println(calculate(listString));
}
/**
* 计算逆波兰表达式最终结果
*
* @param stringList 数据和运算符链表
* @return 计算结果
*/
private static int calculate(List<String> stringList) {
// 创建一个栈
Deque<String> stack = new ArrayDeque<>();
// 开始遍历链表
for (String element : stringList) {
// 如果是数字
if (element.matches("\\d+")) {
stack.push(element);
} else {
// 出栈两个数
int num1 = Integer.parseInt(stack.pop());
int num2 = Integer.parseInt(stack.pop());
int res = switch (element) {
case "+" -> num1 + num2;
case "-" -> num2 - num1;
case "*" -> num1 * num2;
case "/" -> num2 / num1;
default -> throw new RuntimeException("运算符有误");
};
// res入栈
stack.push(res + "");
}
}
return Integer.parseInt(stack.pop());
}
/**
* 将逆波兰表达式的数据和运算符依次放到ArrayList中
*
* @param suffixExpression 逆波兰表达式
* @return 链表
*/
private static List<String> getListString(String suffixExpression) {
String[] strings = suffixExpression.split(" ");
List<String> list = new ArrayList<>();
Collections.addAll(list, strings);
return list;
}
}
4.7 中缀表达式转换为后缀表达式
后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成
后缀表达式。
4.7.1 思路分析
- 初始化两个栈：运算符栈s1和储存中间结果的栈s2
- 从左至右扫描中缀表达式
- 遇到操作数时，将其压s2
- 遇到运算符时，比较其与s1栈顶运算符的优先级：
- 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈
- 否则，若优先级比栈顶运算符的高，也将运算符压入s1
- 否则，将s1栈顶的运算符弹出并压入到s2中，再次与s1中新的栈顶运算符相比
- 遇到括号时：
- 如果是左括号“(”，则直接压入s1
- 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
- …
- 重复步骤2至5，直到表达式的最右边
- 将s1中剩余的运算符依次弹出并压入s2
- 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
4.8 逆波兰表达式计算器完整版
完整版的逆波兰计算器，功能包括如下：
- 支持 + - * / ( )
- 多位数，支持小数
- 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符
public class ReversePolishMultiCalc {
/**
* 匹配 + - * / ( ) 运算符
*/
static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";
static final String LEFT = "(";
static final String RIGHT = ")";
static final String ADD = "+";
static final String MINUS = "-";
static final String TIMES = "*";
static final String DIVISION = "/";
/**
* 加減 + -
*/
static final int LEVEL_01 = 1;
/**
* 乘除 * /
*/
static final int LEVEL_02 = 2;
/**
* 括号
*/
static final int LEVEL_HIGH = Integer.MAX_VALUE;
static Deque<String> stack = new ArrayDeque<>();
static List<String> data = Collections.synchronizedList(new ArrayList<>());
/**
* 去除所有空白符
*
* @param s 字符串
* @return 去除后的字符串
*/
public static String replaceAllBlank(String s) {
// \\s+ 匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
return s.replaceAll("\\s+", "");
}
/**
* 判断是不是数字 int double long float
*
* @param s 字符串
* @return true or false
*/
public static boolean isNumber(String s) {
Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
return pattern.matcher(s).matches();
}
/**
* 判断是不是运算符
*
* @param s 字符串
* @return true or false
*/
public static boolean isSymbol(String s) {
return s.matches(SYMBOL);
}
/**
* 匹配运算等级
*
* @param s 字符串
* @return 匹配的等级
*/
public static int calcLevel(String s) {
if ("+".equals(s) || "-".equals(s)) {
return LEVEL_01;
} else if ("*".equals(s) || "/".equals(s)) {
return LEVEL_02;
}
return LEVEL_HIGH;
}
/**
* 匹配
*
* @param s 字符串
* @return
* @throws Exception
*/
public static List<String> doMatch(String s) throws Exception {
if (s == null || "".equals(s.trim())) {
throw new RuntimeException("data is empty");
}
if (!isNumber(s.charAt(0) + "")) {
throw new RuntimeException("data illeagle,start not with a number");
}
s = replaceAllBlank(s);
String each;
int start = 0;
for (int i = 0; i < s.length(); i++) {
if (isSymbol(s.charAt(i) + "")) {
each = s.charAt(i) + "";
// 栈为空，(操作符，或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈
if (stack.isEmpty() || LEFT.equals(each)
|| ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)) {
stack.push(each);
} else if (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {
// 栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(，最后操作符入栈
while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {
if (calcLevel(stack.peek()) == LEVEL_HIGH) {
break;
}
data.add(stack.pop());
}
stack.push(each);
} else if (RIGHT.equals(each)) {
// ) 操作符，依次出栈入列直到空栈或者遇到了第一个)操作符，此时)出栈
while (!stack.isEmpty()) {
calcLevel(stack.peek());
if (LEVEL_HIGH == calcLevel(stack.peek())) {
stack.pop();
break;
}
data.add(stack.pop());
}
}
start = i; // 前一个运算符的位置
} else if (i == s.length() - 1 || isSymbol(s.charAt(i + 1) + "")) {
each = start == 0 ? s.substring(start, i + 1) : s.substring(start + 1, i + 1);
if (isNumber(each)) {
data.add(each);
continue;
}
throw new RuntimeException("data not match number");
}
}
// 如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/，栈底为+，应该依次出栈入列，可以直接翻转整个stack 添加到队列
Collections.reverse(Collections.singletonList(stack));
data.addAll(new ArrayList<>(stack));
System.out.println(data);
return data;
}
/**
* 算出结果
*
* @param list
* @return
*/
public static Double doCalc(List<String> list) {
Double d = 0d;
if (list == null || list.isEmpty()) {
return null;
}
if (list.size() == 1) {
System.out.println(list);
d = Double.valueOf(list.get(0));
return d;
}
ArrayList<String> list1 = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
list1.add(list.get(i));
if (isSymbol(list.get(i))) {
Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));
list1.remove(i);
list1.remove(i - 1);
list1.set(i - 2, d1 + "");
list1.addAll(list.subList(i + 1, list.size()));
break;
}
}
doCalc(list1);
return d;
}
/**
* 运算
*
* @param s1
* @param s2
* @param symbol
* @return
*/
public static Double doTheMath(String s1, String s2, String symbol) {
Double result = switch (symbol) {
case ADD -> Double.parseDouble(s1) + Double.parseDouble(s2);
case MINUS -> Double.parseDouble(s1) - Double.parseDouble(s2);
case TIMES -> Double.parseDouble(s1) * Double.parseDouble(s2);
case DIVISION -> Double.parseDouble(s1) / Double.parseDouble(s2);
default -> null;
};
return result;
}
public static void main(String[] args) {
// String math = "9+(3-1)*3+10/2";
String math = "12.8 + (2 - 3.55)*4+10/5.0";
try {
doCalc(doMatch(math));
} catch (Exception e) {
e.printStackTrace();
}
}
}
5. 队列
5.1 基本概述
- 队列是一个有序列表，可以用数组或是链表实现
- 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。
5.2 普通队列
5.2.1 使用数组模拟队列
-
队列本身也是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中MaxSize为队列的最大容量
-
因为队列的输出输入是分别从前后端来处理，因此需要两个变量front和rear分别记录前后端的下标，front会随着数据输出而改变，
而rear会随着数据输入而改变
-
front—指向队列头部的数据的前一个位置
-
rear—指向队列尾部的数据
数组模拟队列实现
当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
-
将尾指针往后移：rear + 1 , 当 rear == front 【空】
-
若尾指针 rear 小于队列的最大下标 MaxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 reatr == MaxSize -
1 [队列满]
-
出队列操作getQueue
-
显示队列的情况showQueue
-
查看队列头元素headQueue
-
退出系统exit
注意：rear 是队列最后[含] front 是队列最前元素[不含]
5.2.2 代码实现
public class ArrayQueue {
/**
* 表示数组的最大容量
*/
private int maxSize;
/**
* 模拟队列的头指针---指向队列头部的数据的前一个位置
*/
private int front;
/**
* 模拟队列的尾指针---指向队列尾部的数据
*/
private int rear;
/**
* 用于存储队列元素
*/
private int[] arr;
public ArrayQueue(int maxSize) {
this.maxSize = maxSize;
rear = front = -1;
arr = new int[maxSize];
}
/**
* 判断队列是否已满
*
* @return true or false
*/
public boolean isFull() {
return rear == maxSize - 1;
}
/**
* 判断队列是否为空
*
* @return true or false
*/
public boolean isEmpty() {
return rear == front;
}
/**
* 显示队列当前元素个数
*
* @return 队列当前元素个数
*/
public int size() {
return arr.length;
}
/**
* 添加数据到队列尾部
*
* @param n 添加数据
*/
public void addQueue(int n) {
if (isFull()) {
System.out.println("队列已满，无法插入");
return;
} else {
arr[++rear] = n;
}
}
/**
* 数据出队列
*
* @return 移除的数据
*/
public int getQueue() {
if (isEmpty()) {
throw new RuntimeException("队列为空，不能取数据！！！");
} else {
return arr[++front];
}
}
/**
* 显示队列的所有内容
*/
public void showQueue() {
if (isEmpty()) {
System.out.println("队列空的，没有数据！！！");
return;
}
for (int i = 0; i < size(); i++) {
System.out.printf("arr[%d] = %d\n", i, arr[i]);
}
}
/**
* 显示队列的头数据
*
* @return 队列的头数据
*/
public int headQueue() {
if (isEmpty()) {
throw new RuntimeException("队列为空，没有数据！！！");
}
return arr[++front];
}
}
此种方式存在的问题和优化方案
- 数组使用一次就不能使用了，没有达到复用的效果
- 使用算法，改成一个环形的队列：取模%
5.3 环形队列
5.3.1 使用数组模拟环形队列
此时：front为头部数据的下标，rear为尾部数据的下标的后一个位置
- front就指向队列的头部元素，也就是说arr[front]就是队列的第一个元素，front的初始值 = 0
- rear指向队列的尾部元素的后一个位置，因为希望空出一个空间做为约定，rear的初始值=0
- 当队列满时，条件是
(rear +1) % maxSize= front【满】 - 对队列为空的条件，
rear == front【空】 - 队列中有效的数据的个数
(rear + maxSize - front) % maxSize【rear=1 front=0，元素个数为1】 - 我们就可以在原来的队列上修改得到一个环形队列
5.3.2 代码实现
public class CircleArray {
/**
* 循环队列的最大容量
*/
private int maxSize;
/**
* 循环队列的头指针---直接指向头部
*/
private int front;
/**
* 循环队列的尾指针---指向尾部的下一个位置
*/
private int rear;
/**
* 用于存储队列中的元素
*/
private int[] arr;
public CircleArray(int maxSize) {
this.maxSize = maxSize;
front = rear = 0;
arr = new int[maxSize];
}
/**
* 判断循环队列是否已满
*
* @return true or false
*/
public boolean isFull() {
return (rear + 1) % maxSize == front;
}
/**
* 判断循环队列是否为空
*
* @return true or false
*/
public boolean isEmpty() {
return rear == front;
}
/**
* 向队列添加元素
*
* @param n 添加的元素
*/
public void addQueue(int n) {
if (isFull()) {
System.out.println("队列已满，无法添加！！！");
return;
} else {
arr[rear] = n;
rear = (rear + 1) % maxSize;
}
}
/**
* 移除队列元素
*
* @return 移除的元素
*/
public int getQueue() {
if (isEmpty()) {
throw new RuntimeException("队列为空，无法移除！！！");
} else {
int temp = arr[front];
front = (front + 1) % maxSize;
return temp;
}
}
/**
* 显示队列
*/
public void showQueue() {
if (isEmpty()) {
System.out.println("队列空的，没有数据~~");
return;
}
// 从front开始遍历，遍历多少个元素
for (int i = front; i < front + size(); i++) {
// 加上size之后可能会超过数组范围，需要进行取模
int index = i % maxSize;
System.out.printf("arr[%d]=%d\n", index, arr[index]);
}
}
/**
* 求出当前队列的有效数据个数
*/
public int size() {
return (rear - front + maxSize) % maxSize;
}
/**
* 显示队列的头数据
*
* @return 队列的头数据
*/
public int headQueue() {
// 判断队列是否为空
if (isEmpty()) {
// 通过抛出异常
throw new RuntimeException("队列为空，没有数据~~");
}
return arr[front];
}
}
1089
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
