一、栈
栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。
我们称数据进入到栈的动作压栈，数据从栈中出去的动作为弹栈。
1. 栈实现
实现栈，可以基于数组，也可以基于链表，在此处，我以链表的方式实现栈，在入栈时，使用的头插法。
栈的API设计
public class Stack<T> implements Iterable<T>{
// 记录首结点
private Node head;
// 栈中元素的个数
private int N;
private class Node{
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
public Stack() {
this.head = new Node(null,null);
this.N = 0;
}
// 判断当前栈中元素个数是否为 0
public boolean isEmpty(){
return N == 0;
}
// 获取栈中元素的个数
public int size(){
return N;
}
// 把 t 元素压入栈，使用头插法
public void push(T t){
// 创建新结点
Node newNode = new Node(t, null);
// 让新结点指向原来的第一个结点
newNode.next = head.next;
// 让首结点指向新结点
head.next = newNode;
// 元素个数+1；
N ++;
}
// 弹出栈顶元素
public T pop(){
// 找到首结点指向的第一个结点
Node oldFirst = head.next;
if (oldFirst == null){
return null;
}
// 让首结点指向原来第一个结点的下一个结点
head.next = oldFirst.next;
// 元素个数-1
N --;
return oldFirst.item;
}
@Override
public Iterator<T> iterator() {
return new MyIterator();
}
private class MyIteratorimplements Iterator{
private Node node;
public MyIterator(){
this.node = head;
}
@Override
public boolean hasNext() {
return node.next != null;
}
@Override
public Object next() {
node = node.next;
return node.item;
}
}
}
2. 关于栈的问题
① 括号匹配问题
问题描述：
给定一个字符串，里面可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现
例如：
“(上海)(长安)”：正确匹配
“上海((长安))”：正确匹配
“上海(长安)(北京)(深圳)(南京)”：正确匹配
“上海(长安))”：错误匹配
“((上海)长安”：错误匹配
分析：
- 创建一个栈用来存储左括号
- 从左往右遍历字符串，拿到每一个字符
- 判断该字符是不是左括号，如果是，存入栈中
- 判断该字符串是不是右括号，如果不是，继续下一次循环
- 如果该字符是右括号，则从栈中弹出一个元素t
- 判断元素t是否是null，如果不是，则证明有对相应的左括号，如果不是，则证明没有对应的左括号
- 循环结束后，判断栈中有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
import com.tyt.linear.Stack;
public class BracketsMatchTest {
public static void main(String[] args) {
String str = "上海(长安)()";
boolean match = isMatch(str);
System.out.println(str + "中的括号是否匹配：" + match);
}
/**
* 判断 str 中的括号是否匹配
* @param str 括号组成的字符串
* @return 如果匹配，返回true，如果不匹配，返回false
*/
public static boolean isMatch(String str){
// 创建栈对象，用来存储左括号
Stack<String> charStack = new Stack<>();
// 从左往右遍历字符串
for (int i = 0; i < str.length(); i++) {
String currChar = str.charAt(i)+ "";
// 当前字符为左括号，放入到栈中
if (currChar.equals("(")){
charStack.push(currChar);
}else if(currChar.equals(")")){
// 当前字符是右括号，从栈中弹出一个左括号，并判断弹出的结果是否为null,
// 如果为null证明没有匹配的左括号，如果不为null，则证明有匹配的左括号
String pop = charStack.pop();
if (pop == null)
return false;
}
}
// 判断栈中还有没有剩余的左括号，如果有，则证明括号不匹配
return charStack.size() == 0;
}
}
② 逆波兰表达式求值问题
逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起
中缀表达式：
中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间。
中缀表达式是人们最喜欢的表达式，但是对于计算机而言，中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级。如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。
逆波兰表达式(后缀表达式)：
逆波兰表达式是波兰逻辑学家与1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟他相关的操作数之后。
解题思路：
- 创建一个栈对象oprands存储操作数
- 从左往右遍历逆波兰表达式，得到每一个字符串
- 判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中
- 如果是运算符，则从oprands栈中弹出两个操作数o1,o2
- 使用该运算符计算o1和o2，得到结果result
- 把该结果压入oprands栈中
- 遍历结束后，拿出栈中最终的结果返回
import com.tyt.linear.Stack;
public class ReversePolishNotationTest {
public static void main(String[] args) {
// 中缀表达式 3 *（17-15）+18/6 的逆波兰表达式如下 6 + 3 = 9
String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
int result = caculate(notation);
System.out.println("逆波兰表达式的结果为：" + result);
}
/**
* @param notaion 逆波兰表达式的数组表示方式
* @return 逆波兰表达式的计算结果
*/
public static int caculate(String[] notaion) {
// 定义一个栈，用来存储操作数
Stack<Integer> oprands = new Stack<>();
// 从左往右遍历逆波兰表达式，得到每一个元素
for (int i = 0; i < notaion.length; i++) {
String curr = notaion[i];
// 判断当前元素是运算符还是操作数
Integer o1;
Integer o2;
Integer result;
switch (curr) {
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(curr));
break;
}
}
// 得到栈中最后一个元素，就是逆波兰表达式的结果
return oprands.pop();
}
}
二、队列
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。
1. 队列实现
同栈相同，实现队列，可以基于数组，也可以基于链表，在此处，我仍然以链表的方式实现队列，与实现栈不同的是，在此处插入时我使用的是尾插法。
队列的API设计
public class Queue<T> implements Iterable<T>{
// 记录首结点
private Node head;
// 记录最后一个结点
private Node last;
// 记录队列中元素的个数
private int N;
private class Node{
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
public Queue() {
this.head = new Node(null,null);
this.last = null;
this.N = 0;
}
// 判断队列是否为空
public boolean isEmpty(){
return N==0;
}
// 返回队列中元素的个数
public int size(){
return N;
}
// 向队列中插入元素t
public void enqueue(T t){
if (last == null){
// 尾结点 last 为 null
last= new Node(t,null);
head.next = last;
}else {
// 当前尾结点 last 不为 null
Node newNode = new Node(t, null);
last.next = newNode;
last = newNode;
}
// 元素个数+1
N ++;
}
// 从队列中拿出一个元素
public T dequeue(){
if (isEmpty()){
return null;
}
Node oldFirst = head.next;
head.next = oldFirst.next;
N --;
// 因为出队列其实是在删除元素，因此如果队列中的元素被删除完了，需要重置 last = null;
if (isEmpty())
last=null;
return oldFirst.item;
}
@Override
public Iterator<T> iterator() {
return new MyIterator();
}
private class MyIterator implements Iterator{
private Node node;
public MyIterator(){
this.node = head;
}
@Override
public boolean hasNext() {
return node.next != null;
}
@Override
public Object next() {
node = node.next;
return node.item;
}
}
}
本文含有隐藏内容，请 开通VIP 后查看