1. 栈
1.1 概念
栈是一种基于先进后出(FILO)的数据结构,是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出
的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一
个数据被第一个读出来)。
我们称数据进入到栈的动作为压栈,数据从栈中出去的动作为弹栈。
1.2 代码实现
设计思路:
定义一个链表,入栈时每次都往头结点的下一个元素插(第一个结点),弹栈时也是从第一个结点开始弹起
//栈
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 oldFirst = head.next;
//创建新结点
Node newNode = new Node(t, null);
//让首结点指向新结点
head.next = newNode;
//让新结点指向原来的第一个结点
newNode.next=oldFirst;
//元素个数+1;
N++;
}
//弹出栈顶元素
public T pop(){
//找到首结点指向的第一个结点
Node oldFirst = head.next;
if (oldFirst==null){
return null;
}
//让首结点指向原来第一个结点的下一个结点
head.next=oldFirst.next;
//元素个数-1;
N--;
return oldFirst.item;
}
}
1.3 括号匹配问题
问题描述:
给定一个字符串,里边可能包含"()"小括号和其他字符,请编写程序检查该字符串的中的小括号是否成对出现。
例如:
"(上海)(长安)":正确匹配
"上海((长安))":正确匹配
"上海(长安(北京)(深圳)南京)":正确匹配
"上海(长安))":错误匹配
"((上海)长安":错误匹配
分析思路:
1. 创建一个栈来存储左括号
2. 循环遍历栈中的元素,依此拿到每个元素
3. 判断该字符是左括号,如果是,则放入栈中
4. 判断字符是不是右括号,如果不是,继续下层循环
5. 如果是右括号,则从栈中弹出一个元素
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中的括号是否匹配
* @param str 括号组成的字符串
* @return 如果匹配,返回true,如果不匹配,返回false
*/
public static boolean isMatch(String str) {
//1.创建一个栈用来存储左括号
Stack<String> chars = new Stack<>();
//2.从左往右遍历字符串,拿到每一个字符
for (int i = 0; i < str.length(); i++) {
String currChar = str.charAt(i) + "";
//3.判断该字符是不是左括号,如果是,放入栈中存储
if (currChar.equals("(")) {
chars.push(currChar);
} else if (currChar.equals(")")) {//4.判断该字符是不是右括号,如果不是,继续下一次循环
//5.如果该字符是右括号,则从栈中弹出一个元素t;
String t = chars.pop();
//6.判断元素t是否为null,如果不是,则证明有对应的左括号,如果不是,则证明没有对应的左括号
if (t == null) {
return false;
}
}
}
//7.循环结束后,判断栈中还有没有剩余的左括号,如果有,则不匹配,如果没有,则匹配
if (chars.size() == 0) {
return true;
} else {
return false;
}
}
}
1.4 逆波兰表达式问题
逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法,后缀表
达式的特点:运算符总是放在跟它相关的操作数之后。
普通中缀表达式 | 逆波兰表达式 |
---|---|
a+b | ab+ |
c+(a-b) | cab-+ |
a+(b-c)*d | abc-d*+ |
a*(b-c)+d | abc-*d+ |
分析:
1. 创建一个栈对象存储操作数
2. 循环遍历逆波兰表达式,得到每个字符
3. 判断字符是不是运算符,如果不是,则将该操作数压栈
4. 如果是运算符,则从栈中弹出两个元素
5. 运用该运算符计算出结果,将新结果压栈
6. 遍历结束后,拿到最终结果
/**
* @param notaion 逆波兰表达式的数组表示方式
* @return 逆波兰表达式的计算结果
*/
public static int caculate(String[] notaion) {
//1.创建一个栈对象oprands存储操作数
Stack<Integer> oprands = new Stack<>();
//2.从左往右遍历逆波兰表达式,得到每一个字符串
for (int i = 0; i < notaion.length; i++) {
String curr = notaion[i];
//3.判断该字符串是不是运算符,如果不是,把该该操作数压入oprands栈中
Integer o1;
Integer o2;
Integer result;
switch (curr) {
case "+":
//4.如果是运算符,则从oprands栈中弹出两个操作数o1,o2
o1 = oprands.pop();
o2 = oprands.pop();
//5.使用该运算符计算o1和o2,得到结果result
result = o2 + o1;
//6.把该结果压入oprands栈中
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=o1*o2;
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;
}
2. 队列
2.1 概念
队列是一种基于先进先出(FIFO)的数据结构,是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表,它
按照先进先出的原则存储数据,先进入的数据,在读取数据时先读被读出来。
2.2 代码实现
//队列
public class Queue<T> implements Iterable<T> {
private Node head;
private Node last;
private Integer 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;
}
//判断队列是否为空,是返回true,否返回false
public boolean isEmpty(){
return N==0;
}
//获取队列中元素的个数
public int size(){
return N;
}
//从队列中拿出一个元素
public T dequeue(){
if (isEmpty()){
return null;
}
Node oldFirst = head.next;
head.next=oldFirst.next;
N--;
if (isEmpty()){
last=null;
}
return oldFirst.item;
}
//往队列中插入一个元素
public void enqueue(T t){
if (last==null){
//最后一个元素为空
last = new Node(t,null);
head.next=last;
}else {
Node oldFirst = this.last;
last=new Node(t,null);
oldFirst.next=last;
}
N++;
}
}