内功之---栈

最新推荐文章于 2023-06-15 19:00:39 发布
最新推荐文章于 2023-06-15 19:00:39 发布
阅读量188 收藏
点赞数
分类专栏： java 文章标签： 数据结构 栈 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuruizai110/article/details/104365620
版权

一.栈的介绍

  • 是一个先进后出的有序列表。
  • 限制元素的插入和删除只能在线性表的同一端进行。插入和删除元素的一端称为栈顶，不变化的一段称为栈底。
  • 最先放入的元素在栈底，最后放入的元素在栈顶。

二.栈的使用场景

三.栈的基本操作

     原理图：

代码实现：

 

/** 
 * Project Name:leetcode 
 * File Name:StackDemo.java 
 * Package Name:stack 
 * Date:2020年2月11日下午4:45:24 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package stack;

import java.util.Scanner;

/**
 * ClassName:StackDemo <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月11日 下午4:45:24 <br/>
 * 
 * @author yrz
 * @version
 * @see
 */
public class StackDemo {
	public static void main(String[] agrs) {
		// 测试一下ArrayStack 是否正确
		// 先创建一个ArrayStack对象->表示栈
		Stack stack = new Stack(4);
		String key = "";
		boolean loop = true; // 控制是否退出菜单
		Scanner scanner = new Scanner(System.in);

		while (loop) {
			System.out.println("show: 表示显示栈");
			System.out.println("exit: 退出程序");
			System.out.println("push: 表示添加数据到栈(入栈)");
			System.out.println("pop: 表示从栈取出数据(出栈)");
			System.out.println("请输入你的选择");
			key = scanner.next();
			switch (key) {
			case "show":
				stack.list();
				break;
			case "push":
				System.out.println("请输入一个数");
				int value = scanner.nextInt();
				stack.push(value);
				break;
			case "pop":
				try {
					int res = stack.pop();
					System.out.printf("出栈的数据是 %d\n", res);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case "exit":
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}

		System.out.println("程序退出~~~");
	}
}

//创建栈
class Stack {
	int top = -1;
	int maxsize;
	int arr[];

	public Stack(int maxsize) {
		this.maxsize = maxsize;
		arr = new int[maxsize];// 初始化数组
	}

	// 判断栈空
	public boolean isEmpty() {
		return top == -1;
	}

	// 判断栈满
	public boolean isFull() {
		return top == maxsize - 1;
	}

	// 入栈
	public void push(int data) {
		if (isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		arr[top] = data;
	}

	// 出栈

	public int pop() {
		if (isEmpty()) {
			System.out.println("栈空，无元素");
			return -1;
		}

		int value = arr[top];
		top--;
		return value;
	}
	// 遍历栈

	public void list() {
		if (isEmpty()) {
			System.out.println("栈空，无元素");
			return;
		}
		for (int i = top; i >= 0; i--) {
			System.out.printf("出栈元素为arr[%d]=%d\n", i, arr[i]);
		}
	}
}

四.栈实现计算器（中缀表示）

思路分析：

代码实现：

/** 
 * Project Name:leetcode 
 * File Name:Calculator.java 
 * Package Name:stack 
 * Date:2020年2月11日下午5:20:09 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package stack;

/**
 * ClassName:Calculator <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月11日 下午5:20:09 <br/>
 * 
 * @author yrz
 * @version
 * @see
 */
public class Calculator {
	public static void main(String[] args) {
		Stack2 numStack2 = new Stack2(10);//数字栈
		Stack2 operStack2 = new Stack2(10);//字符栈
		String expression = "34+4*8-9";
		int index = 0;// 用来遍历表达式
		int num1 = 0;
		int num2 = 0;
		char ch = 0;// 记录当前扫描到的字符
		String keepNum = "";// 拼接数字字符
		int res = 0;
		char temp;
		// 判断扫描到的字符是数字还是字符
		while (true) {
			ch = expression.substring(index, index + 1).charAt(0);
			if (operStack2.isOper(ch)) {
				// 判断当前符号栈是否为空，为空直接进符号栈
				if (operStack2.isEmpty()) {
					operStack2.push(ch);
				} else {
					// 判断优先级
					// 优先级高入符号栈，否则数栈弹出两个数，
					// 符号栈弹出当前符号，计算后结果入数栈，当前扫描到的字符入符号栈
					if (operStack2.prioprity(ch) > operStack2.prioprity(operStack2.peek())) {
						operStack2.push(ch);
					} else {
						num1 = numStack2.pop();
						num2 = numStack2.pop();
						temp = (char) operStack2.pop();
						res = operStack2.calculator(num1, num2, temp);
						numStack2.push(res);
						operStack2.push(ch);
					}
				}
			} else {

				keepNum += ch;
				// 已经是最后一个，直接入栈
				if (index == expression.length() - 1) {
					numStack2.push(Integer.parseInt(keepNum));
					break;
				}
				// 如果当前字符的后一位是运算符，字符前面的数字字符串入栈
				if (operStack2.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
					numStack2.push(Integer.parseInt(keepNum));
					// 清空keepNum
					keepNum = "";

				}

			}

			index++;
			// 退出循环
			if (index > expression.length() - 1) {
				break;
			}

		}

		// 按顺序计算数栈和字符栈中的结果
		while (true) {
			// 符号栈为空，跳出循环
			if (operStack2.isEmpty()) {
				break;
			}
			num1 = numStack2.pop();
			num2 = numStack2.pop();
			temp = (char) operStack2.pop();
			res = operStack2.calculator(num1, num2, temp);
			numStack2.push(res);
		}

		// 弹出计算结果

		int value = numStack2.pop();

		System.out.println("表达式最终结果=" + value);
	}
}

//创建栈
class Stack2 {
	int top = -1;
	int maxsize;
	int arr[];

	public Stack2(int maxsize) {
		this.maxsize = maxsize;
		arr = new int[maxsize];// 初始化数组
	}

	// 判断栈空
	public boolean isEmpty() {
		return top == -1;
	}

	// 判断栈满
	public boolean isFull() {
		return top == maxsize - 1;
	}

	// 入栈
	public void push(int data) {
		if (isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		arr[top] = data;
	}

	// 出栈

	public int pop() {
		if (isEmpty()) {
			System.out.println("栈空，无元素");
			return -1;
		}

		int value = arr[top];

		top--;
		return value;
	}
	// 遍历栈

	public void list() {
		if (isEmpty()) {
			System.out.println("栈空，无元素");
			return;
		}

		for (int i = top; i >= 0; i--) {
			System.out.printf("出栈元素为arr[%d]=%d\n", i, arr[i]);
		}
	}

	// 判断当前字符是否是符号

	public boolean isOper(char ch) {
		return ch == '*' || ch == '/' || ch == '+' || ch == '-';
	}

	// 判断运算符的优先级
	public int prioprity(char ch) {
		if (ch == '*' || ch == '/') {
			return 1;
		} else if (ch == '+' || ch == '-') {
			return 0;
		} else {
			return -1;
		}
	}

	// 计算方法

	public int calculator(int num1, int num2, char oper) {

		int res = 0;
		switch (oper) {
		case '*':
			res = num1 * num2;
			break;

		case '/':
			res = num2 / num1;
			break;

		case '+':
			res = num1 + num2;
			break;

		case '-':
			res = num2 - num1;
			break;
		default:
			break;

		}

		return res;
	}

	// 弹出栈顶元素
	public char peek() {
		return (char) arr[top];
	}
}

 五.实现逆波兰计数器

 

中缀表达式转换对应的后缀表

1) 初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；

2) 从左至右扫描中缀表达式；

3) 遇到操作数时,将其压 s2；

4) 遇到运算符时,比较其与 s1 栈顶运算符的优先级：1.如果 s1 为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈；2.否则,若优先级比栈顶运算符的高,也将运算符压入 s1；3.否则,将 s1 栈顶的运算符弹出并压入到 s2 中,再次转到(4-1)与 s1 中新的栈顶运5) 遇到括号时：(1) 如果是左括号“(”,则直接压入 s1(2) 如果是右括号“)”,则依次弹出 s1 栈顶的运算符,并压入 s2,直到遇到左括

6) 重复步骤 2 至 5,直到表达式的最右边

7) 将 s1 中剩余的运算符依次弹出并压入 s2依次弹出    中的元素并输出,结果的逆序即为中缀表达式对应的后缀表

代码实现

/** 
 * Project Name:leetcode 
 * File Name:PoLandNotation.java 
 * Package Name:stack 
 * Date:2020年2月13日上午11:40:58 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * ClassName:PoLandNotation <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月13日 上午11:40:58 <br/>
 * 
 * @author yrz
 * @version
 * @see
 */
public class PoLandNotation {
	public static void main(String[] args) {
		/*
		 * String str="3 4 + 5 * 6 -"; List<String> res =
		 * PoLandNotation.getPoLandList(str); System.out.println(res);
		 * 
		 * System.out.println(); int result = PoLandNotation.Calculator(res);
		 * System.out.println("逆波兰表达式计算结果="+result);
		 */

		// 完成将一个中缀表达式转成后缀表达式的功能
		// 说明
		// 1. 1+((2+3)×4)-5 => 转成 1 2 3 + 4 × + 5 –
		// 2. 因为直接对 str 进行操作,不方便,因此 先将 "1+((2+3)×4)-5" =>
		// 中缀的表达式对应的列表即“1（23）×4）-5”=>Array List[1，（2，3，），*4，），-5]
		// 3。将得到的中缀表达式对应的列表=>后缀表达式对应的列表/即Array List[1，（，（，2，3，），*，4，），-5]
		String expression = "1+((2+3)*4)-5";// 注意表达式
		List<String> res = PoLandNotation.getInfixList(expression);
		System.out.println("中缀list="+res);
		
		System.out.println();
		List<String> resSuf = PoLandNotation.toSuffixList(res);
		
		System.out.println("后缀list="+resSuf);
		System.out.println();
		int result = PoLandNotation.Calculator(resSuf);
		 System.out.println("逆波兰表达式计算结果="+result);
		
	}

	// 中缀表达式存放在ArrayList中
	public static List<String> getInfixList(String s) {
		List<String> infixList = new ArrayList<String>();
		int index = 0;
		char ch = 0;
		String temp = null;// 拼接多个数字
		while (true) {
			ch = s.substring(index, index + 1).charAt(0);
			if (ch < 48 || ch > 57) {
				infixList.add("" + ch);
			} else {
				temp = "";
				if (ch >= 48 || ch <= 57) {
					temp += ch;
				}
				infixList.add(temp);
			}
			index++;
			if (index > s.length() - 1) {
				break;
			}
		}

		return infixList;
	}

	// 中缀list转化为后缀list
	public static List<String> toSuffixList(List<String> infixList) {
		// 运算符栈
		Stack opertorStack = new Stack();
		// 中间结果栈
		Stack intermediateResultStack = new Stack();

		for (String res : infixList) {
			if (res.matches("\\d+")) {
				intermediateResultStack.push(res);
			} else {
				if (opertorStack.isEmpty() ||res.equals("(")|| opertorStack.peek().equals("(")) {
					opertorStack.push(res);
				} else if (res.equals(")")) {
					// 如果是右括号“)”,则依次弹出 opertorStack 栈顶的运算符,并压入 intermediateResultStack,直到遇到左括号为止,此时将这 一对括号丢弃
					while (!opertorStack.peek().equals("(")) {
						intermediateResultStack.push(opertorStack.pop());
					}

					opertorStack.pop();// 消除“（”

				} else {
					// 当 item 的优先级小于等于 opertorStack 栈顶运算符,
					// 将 opertorStack 栈顶的运算符弹出并加入到 intermediateResultStack 中,再次转到(4.1) 与 opertorStack 中新的栈顶运算符相比较

					while (opertorStack.size() != 0 && PoLandNotation.prioprity(res.charAt(0)) <= PoLandNotation
							.prioprity(((String)opertorStack.peek()).charAt(0))) {
						intermediateResultStack.push(opertorStack.pop());
					}
					opertorStack.push(res);
				}

			}

		}
		
		while (opertorStack.size() != 0) {
			intermediateResultStack.push(opertorStack.pop());
		}
		return intermediateResultStack;

	}

	// 将后缀表达式存放到List中
	public static List<String> getPoLandList(String s) {
		List<String> poLandList = new ArrayList<String>();
		String[] spilt = s.split(" ");
		for (String str : spilt) {
			poLandList.add(str);
		}

		return poLandList;
	}

	// 计算后缀表达式
	/*
	 * 1．从左至右扫描,将 3 和 4 压入堆栈； 2．遇到+运算符,因此弹出 4 和 3(4 为栈顶元素,3 为次顶元素),计算出 3+4 的值,得 7,再将
	 * 7 入栈； 3．将 5 入栈； 4．接下来是×运算符,因此弹出 5 和 7,计算出 7×5=35,将 35 入栈； 5．将 6 入栈；
	 * 6．最后是-运算符,计算出 35-6 的值,即 29,由此得出最终结果
	 */

	public static int Calculator(List<String> poLandList) {
		Stack<String> stack = new Stack<String>();
		for (String str : poLandList) {
			if (str.matches("\\d+")) {
				// 数字直接入栈
				stack.push(str);
			} else {
				int num1 = Integer.parseInt(stack.pop());
				int num2 = Integer.parseInt(stack.pop());
				int res = CalculatorInStack(num1, num2, str);
				stack.push(res + "");
			}
		}

		// 最后出战返回结果
		int res = Integer.parseInt(stack.pop());

		return res;
	}

	// 栈内元素进行计算
	public static int CalculatorInStack(int num1, int num2, String str) {
		int res = 0;
		if (str.equals("+")) {
			res = num1 + num2;
		}
		if (str.equals("*")) {
			res = num1 * num2;
		}
		if (str.equals("-")) {
			res = num2 - num1;
		}
		if (str.equals("/")) {
			res = num2 / num1;
		}

		return res;
	}

	// 判断运算符的优先级
	public static int prioprity(char ch) {
		if (ch == '*' || ch == '/') {
			return 1;
		} else if (ch == '+' || ch == '-') {
			return 0;
		} else {
			return -1;
		}
	}
}

 

yuruizai110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 - 栈
李三丧的博客
01-16 195
目录 前言 栈的定义 栈的实现 栈的应用练习 前言 一直都觉得数据结构学了也不知道干什么用，直到最近学习了一下vue的源码，在vue的编译模板阶段，获取一组组标签就是通过栈实现的。所以有一些思考，当你对所谓的一些数据结构、基础算法完全不了解的时候，在遇到问题的时候就完全想不到有这样一个简单的方案解决。有点像内功，没法给你招式，不见得能在工作中大量使用，但是熟悉之后又会提高解决问题的能...
栈（一）
weixin_33709590的博客
06-10 155
栈的介绍 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入...
内功之--链表
yuruizai110的博客
02-13 120
单链表 链表内存存储 头指针 地址 data域 next域 head 150 110 a2 180 120 130 a4 170 140 a6 null 1...
内功之--稀疏数组
yuruizai110的博客
02-02 197
线性结构 数据元素之间存在一对一的线性关系。 存储结构。顺序存储（数组）和链式存储（链表） 。顺序存储的线性表称为顺序表，顺序表中的元素是连续的。 链表中的元素不一定是连续的。 常见的线性结构：数组，对列，链表和栈。 非线性结构 树，图 一.什么是稀疏数组？ 当一个数组中大部分元素为0，或者为同一个值时，可以用稀疏数组来保存该数组。 稀疏数组处理方...
修炼内功---数据结构与算法5---栈
zhangdonghang
12-22 127
&lt;?php /** * 通过 PHP 数组实现简单的顺序栈 */ class SimpleStack { private $_stack = []; private $_size = 0; public function __construct($size = 10) { $this-&gt;_size = $size; }...
JS内功修炼-基础篇
qq_36801609的博客
06-16 243
最近负责前端技术一面，提问他人的时候，会发现js基础知识好多细节自己也不是很扎实，特意找时间统一梳理了一下： 1. JS数据类型 js数据类型分为：基础数据类型（7种）和引用数据类型object。 基础数据类型： null、undefined、 number、 string、 boolean 、symbol（es6）、 bigint(可以表示大于2^53 -1的整数) 引用数据类型：object。object包括array、function、Date、RegExp等 2. 判断数据类型的方式： （1） ty
数据结构1-栈
qq_44177768的博客
10-12 169
数据结构学习
【数据结构与算法】程序内功篇四--栈
修成真的博客
03-10 1991
程序内功篇四--栈一、栈的原理二、顺序栈的实现1、顺序栈原理2、栈的创建3、顺序栈进栈 4、顺序栈出栈5、顺序栈删除6、清空栈与是否清空栈三、链表栈的实现1、栈的单链表实现2、创建空栈3、入栈4、出栈5、删除链表栈6、判断是否为空栈四、栈的应用 一、栈的原理 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈） 允许进行操作的一端称为“栈顶” 另一固定端称为“栈底” 当栈中没有元素时称为“空栈”。栈的特点 ：后进先出（LIFO）。 二、顺序栈的实现 有关顺序表的原理及实现看这篇文章
内功修炼-深入了解函数栈帧
sjp151的博客
08-11 483
函数栈帧基础铺垫局部变量是怎么创建的三级目录 基础铺垫 函数栈帧的创建和销毁，在不同编译器，不同环境下有区别。 寄存器 eax　ebx　ecx　edx 　 ebp　 esp 要理解函数栈帧就必须理解 ebp esp　这两个寄存器中存放的是地址是用来维护函数栈帧的。 每一个函数调用，都要在栈区创建一个空间。 压栈(push)就是从栈区的顶上放一个元素进去，从顶上删除一个元素就叫出栈(pop)。 寄存器是独立于内存的，是在cpu上面的。 操作工具是vs2013，因为vs2013可以看到栈帧的详细过程。 局
编程内功心法-编程算法题库
最新发布
07-14
### 编程内功心法—编程算法题库解析 #### 一、力扣题集概览 **力扣题集**是针对编程面试而设计的一系列算法题目，旨在帮助学习者掌握各种算法技巧和数据结构的应用。这些题目涵盖了广泛的难度级别，从简单到复杂...
程序员内功修炼-V1.0.pdf
04-05
文档中可能详细介绍了数组、链表、栈、队列、树（二叉树、堆、AVL树、红黑树等）、图、散列表等基本数据结构，以及排序（冒泡排序、选择排序、插入排序、快速排序、归并排序等）、查找（线性查找、二分查找、哈希...
C++内功修炼----基础知识的零碎整理
vjhghjghj的博客
05-27 530
c和c++的区别？ 第一点就应该想到C是面向过程的语言，而C++是面向对象的语言，一般简历上第一条都是熟悉C/C++基本语法，了解C++面向对象思想，那么，请问什么是面向对象？ C和C++动态管理内存的方法不一样，C是使用malloc/free函数，而C++除此之外还有new/delete关键字；（关于malooc/free与new/delete的不同又可以说一大堆，最后的扩展_1部分列出十大...
web项目安全漏洞防御实战
yuruizai110的博客
04-20 883
LK最近在对已有项目进行安全漏洞防御，现在将一些心得分享出来和大家一起讨论.主要是从下面几个方面进行漏洞修复。 1. 跨站脚本攻击漏洞（xss） 2. 敏感数据未加密传输 3. 验证机制缺陷 4. Cookie中未设HttpOnly标识 5. 危险的HTTP方法未禁用 1.跨站脚本攻击漏洞（xss） 先来了解一下什么是xss 概念 xss又叫css（cross site script...
itextpdf使用
yuruizai110的博客
04-08 687
LK最近项目中要进行对pdf的操作，具体需求是要在现有pdf文件末尾加入一下文字。 首先需要准备的jar包，itextpdf-5.5.5.jar和itext-asian-5.2.0.jar jar包可以在maven仓库中下 >https://mvnrepository.com/ 下完以后新建项目导入就行 代码 package test; import java.io.File...
springcloud整合nacos
yuruizai110的博客
06-15 664
springcloud整合nacos
算法小记-链表
yuruizai110的博客
04-08 583
基础决定高度
ArrayList源码理解
yuruizai110的博客
10-15 551
LK决定最近撸一下常用集合源码，毕竟在项目里主要用到的就是这些常用集合。要分析的集合源码主要有 ArrayList LinkedList HashMap HashSet LinkedHashMap 一 继承体系 创建ArrayList（）对象，ctrl+T可以看到ArrayList继承体系，主要继续了AbstractList，AbstractCollection.实现了List, Rando...
linkedlist源码分析
yuruizai110的博客
11-25 468
一.继承体系 二.源码分析 添加链表元素 //获取指定索引元素 Node&amp;amp;lt;E&amp;amp;gt; node(int index){ //二分查找 if(index &amp;amp;lt; (size &amp;amp;gt;&amp;amp;gt; 1)){ //如果索引值在链表size/2之内 Node&amp;amp;lt;E&amp;amp;gt; prevN
深入解析LINUX-1.2.13内核网络栈
"这篇文档详细分析了LINUX-1.2.13内核的网络栈实现，旨在为Linux内核爱好者提供学习交流的材料。作者指出，虽然老版本的内核代码...通过这种方式，学习者可以逐步积累“内功”，逐步适应并掌握更复杂、更先进的技术。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值