栈的实现和括号匹配问题和逆波兰表达式的处理笔记

最新推荐文章于 2024-07-10 11:25:20 发布
最新推荐文章于 2024-07-10 11:25:20 发布
阅读量375 收藏 6
点赞数 25
分类专栏： java 笔记 文章标签： linq microsoft c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wuweihendidiao/article/details/122608516
版权
笔记 同时被 2 个专栏收录
33 篇文章 0 订阅
订阅专栏
java
26 篇文章 3 订阅
订阅专栏

目录

栈

代码实现

 括号匹配问题

代码实现

 逆波兰表达式求值问题

代码实现

 

栈

栈是一种基于先进后出的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读取的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)

代码实现

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);
		this.N=0;
		
	}
	//判断当前栈中的元素个数是否为0
	public boolean isEmpty()
	{
		return N==0;
	}
	//获取栈中元素个数
	public int size()
	{
		return N;
	}
	//将元素压入栈，与链表中插入结点的处理几乎一样,只不过一只从头结点插入
	public void push(T t)
	{
		//找到首结点指向的第一个结点
		Node oldFirst=head.next;
		//创建新结点
		Node newNode =new Node(t,null);
		//让首结点指向新结点
		head.next=newNode;
		//让新结点指向原来的第一个结点
		newNode.next=oldFirst;
		N++;//压入了元素，元素肯定变多啦
	}
	//弹出元素,其实就是首结点越过第一个结点，与第二个结点相连(指向原来第一个结点的下一个结点)
	public T pop()
	{
	//找到首结点指向的第一个结点
		Node oldFirst=head.next;//可能是空的链表，所以要安全处理一下下
		if(oldFirst==null)
		{
			return null;
		}
		//让首结点指向原来第一个结点的下一个结点
		head.next=oldFirst.next;
		//弹出元素，肯定元素个数变少了
		N--;
		return oldFirst.item;
	}	
	public Iterator<T> iterator()
	{
		return new Literator();
	}
	private class Literator implements Iterator{
		private Node n;
		public Literator()
		{
			this.n=head;
		}
		public boolean hasNext()
		{
			return n.next!=null;
		}
		public Object 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 i:stack)
	{
		System.out.println(i);
	}
	System.out.println("————————————————————————————————————————————————");
	//测试弹栈
	String result=stack.pop();
	System.out.println("弹出的元素是"+result);
	System.out.println("剩余的元素的个数是:"+stack.size());
	
}	
}

 括号匹配问题

问题描述：给定一个字符串，里面可能包含"()"小括号和其他字符，请编写程序检查该字符串中的小括号是否成对出现。

例如：

"(小无)(小北)":正确

"小无((小北))":正确

"小无(小北(小明)(小南)小丽)":正确

"（(小北)小无"：错误

注意：这个括号成对出现，不是指“()”的数量，而是让左括号（和右括号）一一对应.

处理这道题的技巧主要就是当我们遍历字符串的时候，如果遇到左括号，将其压入栈，遇到右括号，弹出栈的元素，如果没有对应的左括号，弹出的元素是null，可以判断。

到最后到达字符串的末尾，我们得判断栈中是否还有左括号，有的话说明右括号少了，返回false,没有的话满足题意，返回true。

代码实现

public class test {
public static void main(String[] args)
{
String str="(小无(小北)())";
boolean isf=isf(str);
System.out.println(str+"中的括号是否匹配:"+isf);

}	
public static boolean isf(String str)
{
	//创建栈对象，存储左括号
	  Stack<String> chars=new Stack<>();
	//从左往右遍历字符串
	  for(int i=0;i<str.length();i++)
	  {
		  //字符型的话返回不方便，定义成字符串型
		  String currchar=str.charAt(i)+"";
		  //判断是否为左括号，如果是，压入栈
		  if(currchar.equals("("))
				  {
			  chars.push(currchar);
				  }
		  else if(currchar.equals(")"))
		  {//判断是否是右括号，如果是，从栈中弹出元素(左括号)
			  String p= chars.pop();
			  if(p==null)
			  {
				  return false;
			  }
			  
		  }
			  
	  }
	//上面的遍历已经把所有右括号对应是否有左括号并进行操作处理完毕
	//最后我们检查栈中是否还有左括号即可
	  if(chars.size()==0)
	  {
		  return true;
	  }
	  else
	  {
		  return false;
	  }

}

}
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);
		this.N=0;
		
	}
	//判断当前栈中的元素个数是否为0
	public boolean isEmpty()
	{
		return N==0;
	}
	//获取栈中元素个数
	public int size()
	{
		return N;
	}
	//将元素压入栈，与链表中插入结点的处理几乎一样,只不过一只从头结点插入
	public void push(T t)
	{
		//找到首结点指向的第一个结点
		Node oldFirst=head.next;
		//创建新结点
		Node newNode =new Node(t,null);
		//让首结点指向新结点
		head.next=newNode;
		//让新结点指向原来的第一个结点
		newNode.next=oldFirst;
		N++;//压入了元素，元素肯定变多啦
	}
	//弹出元素,其实就是首结点越过第一个结点，与第二个结点相连(指向原来第一个结点的下一个结点)
	public T pop()
	{
	//找到首结点指向的第一个结点
		Node oldFirst=head.next;//可能是空的链表，所以要安全处理一下下
		if(oldFirst==null)
		{
			return null;
		}
		//让首结点指向原来第一个结点的下一个结点
		head.next=oldFirst.next;
		//弹出元素，肯定元素个数变少了
		N--;
		return oldFirst.item;
	}	
	public Iterator<T> iterator()
	{
		return new Literator();
	}
	private class Literator implements Iterator{
		private Node n;
		public Literator()
		{
			this.n=head;
		}
		public boolean hasNext()
		{
			return n.next!=null;
		}
		public Object next()
		{
			n=n.next;
			return n.item;
		}	
	}	
}

 逆波兰表达式求值问题

波兰表达式就是我们平常写的a+b这种式子变成了ab+，运算符号在后面

a+(b-c)变成 abc-+

a+(b-c)*d变为abc-d*+

代码处理的思想和上一个括号匹配问题原理类似，我们遍历字符串的时候判断字符是否是运算符，如果不是，将数字放入栈，如果是操作符，则弹出两个数字使用该运算符计算即可

在把结果放入栈，以便于和其他数字使用运算符计算。主要利用我们栈的原理，放入数先进后出.最后再检查是否到达字符串的末尾，返回最终结果

代码实现

public class test {
public static void main(String[] args)
{
//4*(20-18)+9/3的波兰表达式如下
	String[] notation= {"4","20","18","-","*","9","3","/","+"};
	int result =caculate(notation);
	System.out.println("逆波兰表达式的计算结果为:"+result);
}

public static int caculate(String[] notation)
{
	//定义一个栈，存储操作数
	Stack<Integer>  ap=new Stack<>();
	//从左往右遍历逆波兰表达式，判断当前元素是运算符还是操作数、
	如果是运算符，从栈中弹出2个操作数
	//如果是操作数，将其放入栈中
	for(int i =0;i<notation.length;i++)
	{
		String curr=notation[i];
		Integer b1,b2,result;
		switch(curr) 
		{//此时要注意应该是第二个弹出的元素减去(操作)第一个弹出的元素
		case"+":
			   b1=ap.pop();
			   b2=ap.pop();
			  result=b2+b1;
			ap.push(result);
			break;
		case"-":
	            b1=ap.pop();
	            b2=ap.pop();
	            result=b2-b1;
		        ap.push(result);
		        break;
		case"*": 
			b1=ap.pop();
            b2=ap.pop();
            result=b2*b1;
            ap.push(result);
			break;
		case"/":
			    b1=ap.pop();
	            b2=ap.pop();
	            result=b2/b1;
		        ap.push(result);
			break;
		default:
			ap.push(Integer.parseInt(curr));
			  break;
		}
	}
	//得到栈中的末尾元素，返回结果
	int result=ap.pop();
    return result;	
  }

}
	
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);
		this.N=0;
		
	}
	//判断当前栈中的元素个数是否为0
	public boolean isEmpty()
	{
		return N==0;
	}
	//获取栈中元素个数
	public int size()
	{
		return N;
	}
	//将元素压入栈，与链表中插入结点的处理几乎一样,只不过一只从头结点插入
	public void push(T t)
	{
		//找到首结点指向的第一个结点
		Node oldFirst=head.next;
		//创建新结点
		Node newNode =new Node(t,null);
		//让首结点指向新结点
		head.next=newNode;
		//让新结点指向原来的第一个结点
		newNode.next=oldFirst;
		N++;//压入了元素，元素肯定变多啦
	}
	//弹出元素,其实就是首结点越过第一个结点，与第二个结点相连(指向原来第一个结点的下一个结点)
	public T pop()
	{
	//找到首结点指向的第一个结点
		Node oldFirst=head.next;//可能是空的链表，所以要安全处理一下下
		if(oldFirst==null)
		{
			return null;
		}
		//让首结点指向原来第一个结点的下一个结点
		head.next=oldFirst.next;
		//弹出元素，肯定元素个数变少了
		N--;
		return oldFirst.item;
	}	
	public Iterator<T> iterator()
	{
		return new Literator();
	}
	private class Literator implements Iterator{
		private Node n;
		public Literator()
		{
			this.n=head;
		}
		public boolean hasNext()
		{
			return n.next!=null;
		}
		public Object next()
		{
			n=n.next;
			return n.item;
		}	
	}	
}

 栈——先进后出，万变不离其宗

学习如逆水行舟，不进则退。和小吴一起加油吧！

小吴有想法
关注
  • 25
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 33
    评论
专栏目录
数据结构与算法学习笔记（六）栈的快速入门及使用栈实现逆波兰表达式求解
叶阳洋的博客
08-08 194
0x01 栈 定义：栈（stack）是一个有序线性表，只能在表的一端（称为栈顶，top）执行插入和删除操作。最后插入的元素将第一个被删除。所以，栈也称为后进先出（Last In First Out，LIFO）或先进后出（First In Last Out，FILO）线性表。栈的局限性就是栈的最大空间必须先声明且不能改变。 两个专有操作： – 入栈 (push)：表示在栈中插入一个元素； – 出栈 (pop)：表示从栈中删除一个元素； 试图对一个空栈执行出栈操作称为下溢（underflow）；试图对一个满栈
学习笔记-中缀表达式转逆波兰表达式(后缀表达式)
12-21
中缀表达式转后缀表达式实现计算器(支持括号以及小数点不支持空白符) 思路图: 这里的s2栈我直接改为ArrayList因为最后是栈的结果的逆序，用ArrayList即可。ok上代码: public class PolandNotation { public static...
C++栈解决括号匹配问题、逆波兰表达式问题
qq_43750656的博客
07-19 541
（15/（7-（1+1）））*3）-（2+（1+1）），将某个中缀表达式转换为逆波兰表达式，如果是+-*运算倒是对顺序没什么有要求，但是如果是除法运算，则必须严格按照原式的除法顺序，如果是正常的加减乘，可以先写操作数，再写运算符，如果是除法，则要将操作数按原顺序写，如果是有小括号的优先级，则可以先写操作数，将操作符往右写。1.栈中越先保存的运算符，说明在原式中先被运算了，此时如果当前的运算符和栈中弹出的运算符的优先级是相等的，那么应该先将栈中的运算符加入到后缀表达中。......
day11 || 逆波兰表达式 || 括号匹配
weixin_53148080的博客
11-06 130
leetcode || 逆波兰表达式 || 括号匹配
逆波兰表达式：计算包含括号的四则运算表达式
yumuing‘s bolg
03-06 1661
平时我们进行数学计算使用的常见书写方式就是中缀表达式，即每一个运算符号都位于计算数的中间，如下： (1+2)÷3 (1+2)\div3 (1+2)÷3 而这对于计算机进行求取结果来说，并不是一个最优的方案，毕竟每次读取到一个运算符，都得判断一次优先级，并且需要确定两个计算数的目标位置。在四则运算的基础之上，还在添加一个括号的使用，这将更为复杂，中缀表达式将更加对计算机不友好。那什么样的表达式结构会是计算机较为优化的呢？ 答案就是逆波兰表达式，也叫做后缀表达式，它最大的好处就是无需再考虑运算符的优先级，也无需
leetcode-150. 逆波兰表达式求值
qq_38888209的博客
09-24 348
逆波兰表达式求值 根据 逆波兰表示法，求表达式的值。 有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 输入: [“2”, “1”, “+”, “3”, “*”] 输出: 9 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 示例 2： 输入: [“4”, “13”, “5”, “/”, “+”.
【C++学习】一些笔记 04 栈（数组和链表实现+leetcode 150 逆波兰表达式实现）
Estelle1412的博客
02-08 85
栈的一些知识，用数组和链表实现栈
(Java)数据结构之栈(Stack) ，附有三个栈相关OJ题目和对应做法（括号匹配，逆波兰表达式求值，出栈入栈次序匹配）
2401_84411018的博客
04-20 1033
文中展示的资料包括：**《MySql思维导图》《MySql核心笔记》《MySql调优笔记》《MySql面试专题》《MySql性能优化的21个最佳实践》《MySq高级知识笔记》**如下图。3. 拿到栈顶的元素与前面所拿到字符串的元素作比较，如果括号匹配，则栈顶元素出栈，结束当前循环，继续进行后续比较，如果括号不匹配，则返回false。4. 当字符串的元素比较完后，判断栈是否有剩余，如果有剩余，则返回false，无剩余则返回true。1. 当入栈序列的元素小于出栈序列的第一个元素，将入栈序列的元素依次入栈。
【算法入门】 有效括号序列 逆波兰表达式求值 点击消除_辅助栈包含头文件
2401_84170391的博客
05-06 522
所谓逆波兰表达式就是：操作数在前，操作符在后，入研究，那么很难做到真正的技术提升。
Android 从零学数据结构与算法（2）——栈和队列（Stack、Vector源码分析、逆波兰表达式、队列）
ZhangJiaNan_Marks的博客
05-20 514
    本博客的原创文章，都是本人平时学习所做的笔记，不做商业用途，如有侵犯您的知识产权和版权问题，请通知本人，本人会即时做出处理删除文章。栈：栈是限定仅在表尾进行插入和删除操作的线性表。队列：队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。栈    允许插入和删除的一端为栈顶（Top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出的线性表。   ...
逆波兰表达式计算器代码.zip
10-15
逆波兰表达式计算器通过栈数据结构来解析和计算这种表达式。当遇到数字时，将其压入栈；遇到操作符时，弹出栈顶的两个元素进行运算，并将结果重新压回栈。这样，最后栈顶的元素就是表达式的计算结果。 在这个代码...
ruc-波兰表达式c语言递归demo笔记
05-28
递归通常用于解决可以分解为更小相同问题的问题，如计算阶乘、遍历树形结构或处理波兰表达式。在解析波兰表达式时，我们可以编写一个函数，该函数接受一个栈和一个表达式字符串作为参数。每次函数调用都会检查表达式...
栈和队列从小白到入门的学习路径
04-03
- **表达式求值**：逆波兰表示法（RPN，也称后缀表达式）就是利用栈来计算表达式的结果。 - **网页浏览历史记录**：浏览器的后退功能就是一个栈的实例，新访问的页面压入栈，后退操作则从栈顶弹出页面。 **3. 队列...
MySql官方手册学习笔记2 MySql的模糊查询和正则表达式
12-15
SQL模式匹配允许你使用“_”匹配任何单个字符，而“%”匹配任意数目字符(包括零字符)。在 MySQL中，SQL的模式默认是忽略大小写的。下面给出一些例子。注意使用SQL模式时，不能使用=或!=；而应使用LIKE或NOT LIKE...
使用Java构建可靠的消息传递系统
微赚淘客开发者博客
07-08 443
在现代分布式应用中，消息传递系统扮演着至关重要的角色。它们用于实现异步通信、解耦系统组件以及处理高并发的消息处理需求。本文将探讨如何使用Java构建可靠的消息传递系统，通过示例代码详细展示核心概念和技术实现。本文介绍了如何使用Java构建可靠的消息传递系统，主要涉及消息队列的选择与配置、消息消费者的实现以及如何处理消息传递系统中的事务。通过合理选择消息队列和技术实现，可以提升系统的可靠性和性能，满足复杂的消息处理需求。微赚淘客系统3.0小编出品，必属精品，转载请注明出处！
Kafka-02 @KafkaListener学习
最新发布
qq_45149567的博客
07-10 523
SpringBoot 和 Kafka 搭配使用的场景，引入 spring-kafka 即可；</</</</
Spring Boot与Apache Kafka Streams的集成
微赚淘客开发者博客
07-06 922
通过本文，我们详细介绍了如何在Spring Boot应用程序中集成Apache Kafka Streams，包括添加依赖、配置Kafka连接、编写Kafka Streams处理拓扑和消费者/生产者。Apache Kafka Streams作为强大的流处理框架，与Spring Boot的集成能够为应用程序提供可靠和高效的实时数据处理能力。Apache Kafka Streams是一个用于构建实时流应用程序的库，基于Apache Kafka消息系统。使用Kafka命令行工具或自定义生产者发送消息到。
微软Win11 24H2七月更新补丁KB5040435发布！附下载
lihuiyun184291的博客
07-10 372
系统之家于7月10日发出最新报道，微软为Win11用户发布了24H2版本七月的最新更新补丁KB5040435。用户升级系统后，会发现版本号升至 26100.1150。此次更新针对远程身份验证拨入用户服务（RADIUS）协议与 MD5冲突等问题进行修复。接下来跟随小编看看此次更新的详细信息。
用栈实现四则运算的笔记
05-25
栈是一种先进后出（Last-In-First-Out）的数据结构，...需要注意的是，这里的实现并不支持带括号的表达式，如果需要支持括号，则需要对表达式进行转换，将括号内的表达式转换为逆波兰表达式，并递归地计算表达式的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小吴有想法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值