前言
为了面试，时隔一年不得不重新复习数据结构与算法，这次重新复习很有收获，以前在上课总有不清晰的知识，通过这次手写一遍和敲一遍代码，以前不清晰的知识都变得清晰了，果然学编程还是得多敲代码，多敲代码，多敲代码，也要多总结，多总结，多总结。
学习资源
视频 黑马程序员 数据结构与算法
栈
栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。
我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。
import java.util.Iterator;
//栈
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);
N=0;
}
//判断当前栈中元素个数是否为0
public boolean isEmpty(){
return N==0;
}
//获取栈中元素的个数
public int size(){
return N;
}
//把t元素压入栈
public void push(T t){
//找到首结点指向的第一个结点
Node oldTop = head.next;
//创建新结点
Node newTop = new Node(t,null);
//让首结点指向新结点
head.next = newTop;
//让新结点指向原来的第一个结点
newTop.next = oldTop;
//元素个数+1；
N++;
}
//弹出栈顶元素
public T pop(){
Node oldTop = head.next;
if(oldTop==null){
return null; //空栈
}
//让首结点指向原来第一个结点的下一个结点
head.next = oldTop.next;
//元素个数-1；
N--;
return oldTop.item;
}
//重写迭代器遍历方法
//实现Iterable接口，重写接口的iterator方法；
@Override
public Iterator<T> iterator() {
return new SIterator();
}
//实现Iterator接口，重写hasNext方法和next方法；
private class SIterator implements Iterator<T>{
private Node n;
public SIterator(){
this.n=head;
}
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public T next() {
n = n.next;
return n.item;
}
}
//测试
public static void main(String[] args) {
//创建栈对象
Stack<String> stack =new Stack<String>();
//测试压栈
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());
}
}
1.括号匹配问题
1.创建一个栈用来存储左括号
2.从左往右遍历字符串，拿到每一个字符
3.判断该字符是不是左括号，如果是，放入栈中存储
4.判断该字符是不是右括号，如果不是，继续下一次循环
5.如果该字符是右括号，则从栈中弹出一个元素t；
6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号
7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
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){
//1.创建栈对象，用来存储左括号
Stack<String> chars = new Stack<String>();
//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.继续判断当前字符是否是右括号，如果是，
//则从栈中弹出一个左括号
String t = chars.pop();
//并判断弹出的结果是否为null,如果为null证明没有匹配的左括号，如果不为null，则证明有匹配的左括号
if(t==null){
return false;
}
}
}
//5.判断栈中还有没有剩余的左括号，如果有，则证明括号不匹配
if(chars.size()==0){
return true;
}else{
return false;
}
}
}
2.逆波兰表达式求值问题
中缀表达式：
中缀表达式就是我们平常生活中使用的表达式，例如：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+ |
需求：
给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。
分析：
1 1.创建一个栈对象oprands存储操作数
2 2.从左往右遍历逆波兰表达式，得到每一个字符串
3 3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中
4 4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
5 5.使用该运算符计算o1和o2，得到结果result
6 6.把该结果压入oprands栈中
7 7.遍历结束后，拿出栈中最终的结果返回
//逆波兰表达式
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); //9
}
/**
* @param notaion 逆波兰表达式的数组表示方式
* @return 逆波兰表达式的计算结果
*/
public static int caculate(String[] notaion) {
//1.定义一个栈，用来存储操作数
Stack<Integer> oprands = new Stack<Integer>();
//2.从左往右遍历逆波兰表达式，得到每一个元素
for (int i = 0; i < notaion.length; i++) {
String curr = notaion[i];
//3.判断当前元素是运算符还是操作数
Integer o1; //操作数1
Integer o2; //操作数2
Integer result; //结果
switch (curr) {
case "+":
//4.运算符，从栈中弹出两个操作数，完成运算
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 + o1;
oprands.push(result); //运算完的结果再压入栈中
break;
case "-":
//4.运算符，从栈中弹出两个操作数，完成运算
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 - o1;
oprands.push(result); //运算完的结果再压入栈中
break;
case "*":
//4.运算符，从栈中弹出两个操作数，完成运算
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 * o1;
oprands.push(result); //运算完的结果再压入栈中
break;
case "/":
//4.运算符，从栈中弹出两个操作数，完成运算
o1 = oprands.pop();
o2 = oprands.pop();
result = o2 / o1;
oprands.push(result); //运算完的结果再压入栈中
break;
default:
//5.操作数，把该操作数放入到栈中；
oprands.push(Integer.parseInt(curr));
break;
}
}
//6.得到栈中最后一个元素，就是逆波兰表达式的结果
int result = oprands.pop();
return result;
}
}
2595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
