代码中的Node类：
下面展示一些 Node类。
package LinkTable;
/**
* @author shkstart
* @create 2021-08-10 10:54
*/
public class Node<T> {
//存储元素
public T item;
//指向下一个节点
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
3 栈
3.1 栈概述
把生活中的栈的概念引入到计算机中，就是供数据休息的地方，它是一种数据结构，数据既可以进入到栈中，又可以从栈中出去。
栈是一种基于先进后出(FILO)的数据结构（进栈元素顺序和出栈元素顺序相反），是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。
我们称数据进入到栈的动作为压栈（Push），数据从栈中出去的动作为弹栈（Pop）。
3.2 栈的实现
3.2.1 栈API设计
3.2.2 栈代码实现
下面展示一些 栈代码实现。
package LinkTable;
import java.util.Iterator;
/**
* @author shkstart
* @create 2021-08-12 20:47
*/
public class Stack<T> implements Iterable<T> {
public static void main(String[] args) {
//创建栈对象
Stack<String> stack = new Stack<>();
//测试压栈
stack.push("a");
stack.push("b");
stack.push("c");
stack.push("d");
for (String item : stack) {
System.out.println(item);
}
System.out.println("------------------------------");
//测试弹栈
String result = stack.pop();
System.out.println("弹出的元素是："+result);
System.out.println("剩余的元素个数："+stack.size());
}
private Node head;
private int Num;
public Stack() {
this.head = new Node(null,null);
Num = 0;
}
//判断当前栈是否为空
public boolean isEmpty() {
return Num == 0;
}
//获取栈元素的个数
public int size() {
return Num;
}
//向栈中压入元素t
public void push(T t){
//找到头结点指向的第一个结点(即第一个元素
Node oldFirst = head.next;
//创建新的结点
Node newNode = new Node(t, null);
//让首结点指向新的结点
head.next = newNode;
//新结点指向原来的第一个结点
newNode.next = oldFirst;
//元素个数加1
Num++;
}
//弹出栈顶元素,弹栈和压栈的两者链表之间的机制没有任何关系，各自执行相应的规则
public T pop() {
//找到首结点指向的第一个元素
Node oldFirst = head.next;
if (oldFirst == null){
return null;
}
//让首结点指向原来第一个结点的下一个结点
head.next = oldFirst.next;
//元素个数减1
Num--;
return (T) oldFirst.item;
}
//对接口中的iterator方法进行重写,对集合中的元素进行遍历
@Override
public Iterator<T> iterator() {
return new StackIterator();
}
private class StackIterator implements Iterator {
//建立一个节点的成员变量
private Node n;
//使用构造器初始化首结点为head
public StackIterator() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public T next() {
n = n.next;
return (T) n.item;
}
}
}
3.3 案例
3.3.1 括号匹配问题
问题描述:
给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。
例如：
“(上海)(长安)”：正确匹配
“上海((长安))”：正确匹配
“上海(长安(北京)(深圳)南京)”:正确匹配
“上海(长安))”：错误匹配
“((上海)长安”：错误匹配
分析：
1.创建一个栈用来存储左括号
2.从左往右遍历字符串，拿到每一个字符
3.判断该字符是不是左括号，如果是，放入栈中存储
4.判断该字符是不是右括号，如果不是，继续下一次循环
5.如果该字符是右括号，则从栈中弹出一个元素t；
6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号
7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
下面展示一些 通过栈完成括号匹配问题。
package LinkTable;
/**
* @author Fantic
* @create 2021-08-12 22:09
*/
public class BracketsMatch {
public static void main(String[] args) {
String str = "(上海(长安)()";
boolean isMatch = isMatch(str);
System.out.println(str + "中的括号是否匹配：" + isMatch);
}
//判断Str中的括号是否能对应匹配
public static boolean isMatch(String str){
//1.创建栈对象，用来存储左括号
Stack<String> stack = new Stack<>();
//2.遍历字符串str
for (int i = 0; i < str.length(); i++) {
//注意：将String转变为char型数组，""中不能有空格
String curChar = str.charAt(i) + "";
//3.判断当前字符是否为左括号,如果是,压入栈中
if (curChar.equals("(")) {
stack.push(curChar);
} else if (curChar.equals(")")) {
//4.继续遍历字符.当前字符是否是否是右括号,如果是.则从栈中弹出一个左括号.
// 如果最终谈出的结果为null,则证明左右括号不对应
String pop = stack.pop();
if (pop == null){
return false;
}
}
}
//5.判断栈中是否还有剩余左括号,如果有就返回false
if (stack.size() == 0) {
return true;
}else {
return false;
}
}
}
3.3.2 逆波兰表达式求值问题
中缀表达式：
中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间。
中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。
逆波兰表达式(后缀表达式)：
逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟它相关的操作数之后。
分析：
1.创建一个栈对象oprands存储操作数
2.从左往右遍历逆波兰表达式，得到每一个字符串
3.判断该字符串是不是运算符，如果不是，把该操作数压入oprands栈中
4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
5.使用该运算符计算o1和o2，得到结果result
6.把该结果压入oprands栈中
7.遍历结束后，拿出栈中最终的结果返回
下面展示一些 栈实现逆波兰表达式求值问题。
package LinkTable;
/**
* @author Fantic
* @create 2021-08-12 22:40
*/
public class ReversePolishNote {
public static void main(String[] args) {
//中缀表达式 3*（17-15）+18/6 的逆波兰表达式如下 6+3=9
String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
int caculate = caculate(notation);
System.out.println("逆波兰表达式的结果是：" + caculate);
}
public static int caculate(String[] notion){
//1.定义一个栈，用来存储运算符
Stack<Integer> oprands = new Stack<>();
//2.遍历逆波兰表达式
for (int i = 0; i < notion.length; i++) {
String cur = notion[i];
//判断当前元素是元素还是运算符
Integer o1;
Integer o2;
Integer result;
switch (cur){
case "+":
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 + o1;
oprands.push(result);
break;
case "-":
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 - o1;
oprands.push(result);
break;
case "*":
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 * o1;
oprands.push(result);
break;
case "/":
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 / o1;
oprands.push(result);
break;
default:
oprands.push(Integer.parseInt(cur));
}
}
//得到栈中的最后一个元素
int result = oprands.pop();
return result;
}
}
4 队列
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。（这与栈相反，出队列的元素与进入队列的元素顺序一致）
4.1 队列的API设计
4.2 队列的实现
下面展示一些 队列的代码实现。
package LinkTable;
import java.util.Iterator;
/**
* @author Fantic
* @create 2021-08-13 10:07
*/
public class Queue<T> implements Iterable<T>{
public static void main(String[] args) {
Queue<String> queue = new Queue<>();
//向队列中插入元素
queue.enqueue("a");
queue.enqueue("b");
queue.enqueue("c");
queue.enqueue("d");
for(String str : queue){
System.out.println(str);
}
System.out.println("***********");
//测试元素出队列
String s = queue.dequeue();
System.out.println("出队列的元素是：" + s);
System.out.println("剩余的元素个数是：" + queue.size());
}
//记录首结点
private Node head;
//当前队列的元素个数
private int Num;
//记录最后一个结点,区别于栈
private Node last;
//创建空参构造器,对属性进行初始化
public Queue() {
this.head = new Node(null,null);
Num = 0;
this.last = null;
}
//判断队列是否为空,是则返回true
public boolean isEmpty() {
return Num == 0;
}
//获取队列中的元素个数
public int size() {
return Num;
}
//往队列中插入一个元素
public void enqueue(T t){
if (last == null) {
//当前尾结点是null时,队列中不含有其他元素,新进元素,即为头结点的下一节点,也是尾结点
last = new Node(t, null);
head.next = last;
}else {
//当前尾结点不是null时,队列中含有元素,定义原有的尾结点为新节点的前一个结点
Node oldLast = last;
last = new Node(t, null);
oldLast.next = last;
}
//元素个数加1
Num++;
}
//从队列中拿出一个元素
public T dequeue() {
if (isEmpty()) {
return null;
}
Node oldFirst = head.next;
head.next = oldFirst.next;
//元素个数减1
Num--;
//队列元素出去,就相当于删除元素
if (isEmpty()) {
last = null;
}
return (T) oldFirst.item;
}
//考虑到要遍历元素,需要对队列采取Iterable进行重写
@Override
public Iterator<T> iterator() {
return new QIterator();
}
private class QIterator implements Iterator<T> {
private Node n;
public QIterator() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public T next() {
n = n.next;
return (T) n.item;
}
}
}
4796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
