1 栈
1.1 简介
- 栈是一种基于先进后出（FILO）的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表；
- 先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）；
- 称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈；
1.2 API设计
| 类名 | Stack |
|---|---|
| 构造方法 | Stack()：创建Stack对象 |
| 成员方法 | 1.public boolean isEmpty()：判断栈是否为空，是返回true，否返回false 2.public int size()：获取栈中元素的个数 3.public T pop()：弹出栈顶元素 4.public void push(T t)：向栈中压入元素t |
| 成员变量 | 1.private Node head：记录首结点 2.private int N：当前栈的元素个数 |
1.3 代码
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() {
head = new Node(null,null);
N=0;
}
//判断栈是否为空
public boolean isEmpty(){
return N==0;
}
//获取栈中元素的个数
public int size(){
return N;
}
//把t元素压入栈
public void push(T t){
//找到首结点指向的第一个结点
Node oldFirst = head.next;
//创建新结点，并让其指向原来的第一个结点
Node newNode = new Node(t, oldFirst);
//让首结点指向新结点
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 SIterator();
}
private class SIterator implements Iterator{
private Node n = head;
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public T next() {
n = n.next;
return n.item;
}
}
}
public class Test {
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 str : stack) {
System.out.print(str + " ");
}
System.out.println("\n--------------------");
String result = stack.pop();
System.out.println("弹出了元素：" + result);
System.out.println(stack.size());
}
}
d c b a
--------------------
弹出了元素：d
3
1.4 括号匹配问题
问题描述
给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。
例如：
- “(上海)(长安)”：正确匹配
- “上海((长安))”：正确匹配
- “上海(长安(北京)(深圳)南京)”:正确匹配
- “上海(长安))”：错误匹配
- “((上海)长安”：错误匹配
解题思路
1.创建一个栈用来存储左括号 ；
2.从左往右遍历字符串，拿到每一个字符 ；
3.判断该字符是不是左括号，如果是，放入栈中存储 ；
4.判断该字符是不是右括号，如果不是，继续下一次循环 ；
5.如果该字符是右括号，则从栈中弹出一个元素t；
6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号，不匹配；
7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配；
代码
public class BracketsMatch {
public static void main(String[] args) {
String str = "(fdafds(fafds)())";
boolean match = isMatch(str);
System.out.println(str + "中的括号是否匹配：" + match);
}
//判断str中的括号是否匹配
public static boolean isMatch(String str) {
//1.创建一个栈用来存储左括号
Stack<String> stack = new Stack<>();
//2.从左到右遍历字符串
for (int i=0; i<str.length(); i++) {
String cur_char = str.charAt(i) + "";
//3.判断该字符是不是左括号，如果是，压入栈
if (cur_char.equals("(")) {
stack.push(cur_char);
} else if (cur_char.equals(")")) {//4.判断该字符是不是右括号，如果不是，继续下一次循环
//5.如果该字符是右括号，则从栈中弹出一个元素t
String t = stack.pop();
//6.判断t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号
if (t == null) return false;
}
}
//7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
if (stack.size() == 0) {
return true;
} else {
return false;
}
}
}
(fdafds(fafds)())中的括号是否匹配：true
1.5 逆波兰表达式求值问题
逆波兰表达式求值问题是计算机中经常遇到的一类问题，要研究这个问题，首先要知道什么是逆波兰表达式，这就需要从中缀表达式说起了。
中缀表达式
- 中缀表达式就是我们平常生活中使用的表达式，例如：1 + 3 * 2，2 - (1 + 3)等，其特点是：二元运算符总是置于两操作数中间；
- 中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作；
逆波兰表达式(后缀表达式)
逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟它相关的操作数之后。
| 中缀表达式 | 逆波兰表达式 |
|---|---|
| a+b | ab+ |
| a+(b-c) | abc-+ |
| a+(b-c)*d | abc-d*+ |
| a*(b-c)+d | abc-*d+ |
需求
给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。
算法流程
- 创建一个栈对象oprands存储操作数 ；
- 从左往右遍历逆波兰表达式，得到每一个字符串 ；
- 判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中 ；
- 如果是运算符，则从oprands栈中弹出两个操作数o1,o2 ；
- 使用该运算符计算o1和o2，得到结果result ；
- 把该结果压入oprands栈中 7.遍历结束后，拿出栈中最终的结果返回；
代码
public class ReversePolishNotation {
public static void main(String[] args) {
//中缀表达式3*(17-15)+18/6的逆波兰表达式如下
String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
int result = calculate(notation);
System.out.println("逆波兰表达式的结果为：" + result);
}
public static int calculate(String[] notation) {
//创建一个栈对象oprands存储操作数
Stack<Integer> oprands = new Stack<>();
//从左到右遍历逆波兰表达式，得到每一个字符串
for (int i=0; i<notation.length; i++) {
String curr = notation[i];
//判断该字符串是不是运算符，如果不是，把该操作符压入oprands栈中;
// 如果是运算符，则从oprands栈中弹出两个操作数o1,o2，并使用该运算符计算o1和o2的结果，再把结果压入oprands栈中
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;
}
}
//遍历结束后，拿出栈中最终的结果返回
Integer result = oprands.pop();
return result;
}
}
逆波兰表达式的结果为：9
2 队列
2.1 简介
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先被读出来；
2.2 API设计
| 类名 | Queue |
|---|---|
| 构造方法 | Queue()：创建Queue对象 |
| 成员方法 | 1.public boolean isEmpty()：判断队列是否为空，是返回true，否返回false 2.public int size()：获取队列中元素的个数 3.public T poll()：从队列中拿出一个元素 4.public void offer(T t)：往队列中插入一个元素 |
| 成员变量 | 1.private Node head：记录首节点 2.private int N：当前栈的元素个数 3.private Node last：记录最后一个节点 |
2.3 代码
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 offer(T t){
if (last==null){
//当前尾结点last为null
last= new Node(t,null);
head.next = last;
}else {
//当前尾结点last不为null
Node oldLast = last;
last = new Node(t, null);
oldLast.next = last;
}
//元素个数+1
N++;
}
//从队列中拿出一个元素
public T poll(){
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 QIterator();
}
private class QIterator implements Iterator{
private Node n;
public QIterator(){
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}
}
public class Test {
public static void main(String[] args) throws Exception {
Queue<String> queue = new Queue<>();
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
for (String str : queue) {
System.out.print(str + " ");
}
System.out.println("----------------------------");
String result = queue.poll();
System.out.println("出列了元素：" + result);
System.out.println(queue.size());
}
}
a b c d ----------------------------
出列了元素：a
3
1793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
