java 用栈实现（(a+b)+c）计算

Posted 2023-04-21

数据结构学的不好，老师让我们用栈来计算，用文件读取计算表达式然后算出来，我知道，先挨个（，a,+,b,)入栈，然后当遇到）时出站计算再压入栈再入+，c入栈接着计算，我知道思想但不会数据结构栈操作

楼主您好！
友情提示：
一.在复制代码前需要自己添加类。
二.调用方法都为静态，请你仔细查看代码并以修改。
三.注意我的包名。
ParseExpression.calculateExp(postExperssion.toString());
请把上句的引用改为你的类名。
代码欣赏：

package com.qs.impStackCode;

public class Stack

/**
* @param args
*/
private int maxsize;
int[] stackArray;
int top = -1;

public Stack(int s)
maxsize = s;
stackArray = new int[maxsize];


protected void push(int value)
if(top >= maxsize)
System.out.println("您存放的存储空间栈已经装满了。");
else
stackArray[++top] = value;


protected int pop()
if(top < 0)
System.out.println("当前的栈无数据，已经空了。");
return -1;

return stackArray[top--];


public long peek()
return stackArray[top];


protected boolean isEmpty()
return (top == -1);


protected boolean isFull()
return (top == maxsize - 1);


//判断操作符号
public boolean isOperator(int operator)
if(operator == 42 || operator == 43 ||
operator == 45 || operator == 47 ||
operator == 41 || operator == 40)
return true;
else
return false;


//设置操作符的优先级
public int priority(int operator)
if(operator == 43 || operator == 45 || operator == 40)
return 1;
else if(operator == 42 || operator == 47)
return 2;
else
return 0;


public int result(int operator, int operand1, int operand2)
switch(operator)
case 43:
return (operand2 + operand1);
case 45:
return (operand2 - operand1);
case 42:
return (operand2 * operand1);
case 47:
return (operand2 / operand1);

return 0;


以上是栈类。
以下是逻辑类。

package com.qs.impStackCode;

import java.io.*;

public class ParseExpression

/**
* @param args
*/
protected static String getStr() throws IOException
BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
return read.readLine();


public static void main(String[] args)
// TODO Auto-generated method stub
Stack operator = new Stack(20);
String experssion = null;
//由于我们在数学应中采用都是前序表达所以不得不把它转换成后序或是中序便于处理，
//所以你在代码中看到的postExperssion.append()就是解析好后的后序表达式
StringBuffer postExperssion = new StringBuffer();
int position = 0;
int operator1;
System.out.print("请您输入前序表达试：");
/*
* 读取的是操作数就直接输出。读取的是运算符，该运算符是左括号 ‘（’就把运算符临时存
* 于堆栈中等到循环过程中遇见‘）’就把运算符号从堆栈中取出来。
* 若该运算符不是括号‘（）’那么就对操作符“+ - * \/”号进行比较，当前比较的运算符号较低时
* 就停致备用，和下个运算符号进行比较，如果相反则存入堆栈中。直到所有算术式解析完为止
*/
try
experssion = ParseExpression.getStr();
while(true)
//判断是否是运算符
if(operator.isOperator((int) experssion.charAt(position)))
if(operator.top == -1 || (char) experssion.charAt(position) == '(')
//把运算符存入堆栈中
operator.push(experssion.charAt(position));
else
if((char) experssion.charAt(position) == ')')
//取出运算符直到去出'('
if(operator.stackArray[operator.top] != 40)
operator1 = operator.pop();
postExperssion.append((char)operator1);

else
if(operator.priority((int) experssion.charAt(position))
<= operator.priority(operator.stackArray[operator.top]) &&
operator.top != -1)
operator1 = operator.pop();
if(operator1 != 40)
postExperssion.append((char)operator1);

operator.push(experssion.charAt(position));


else
postExperssion.append(experssion.charAt(position));
position++;
if(position >= experssion.length()) break;

catch (IOException e)
// TODO Auto-generated catch block
e.printStackTrace();

while(operator.top != -1)//取出在堆栈中的所有运算符
operator1 = operator.pop(); postExperssion.append((char)operator1);
//System.out.println(postExperssion.toString()); ParseExpression.calculateExp(postExperssion.toString());


//这个方法属于后续运算方法，就是表达式解析为后序的式子
//如：8/7+(7-2)*4 解析后变成这样 87/72-4*+
/*
* 算法解释：从左至右读取运算单元
* 读取操作数存入堆栈，读取运算符取出操作数进行运算
* 当操作数读完后，即为表达式运算结果
*/
public static void calculateExp(String experssion)
Stack operand = new Stack(20);

int position = 0;
int operand1 = 0;
int operand2 = 0;
int executeResult = 0;

while(true)
if(operand.isOperator(experssion.charAt(position)))
operand1 = operand.pop();
operand2 = operand.pop();

operand.push(operand.result(experssion.charAt(position),
operand1, operand2));
else
//存入操作数需要做ASCII转换，在这我把其它符号的ASCII
//一并写出来 '[' 91 ']' 93 '' 123 '' 125
operand.push(experssion.charAt(position) - 48);
position++;
if(position >= experssion.length())
break;


executeResult = operand.pop();
System.out.print("被计算的表示式：" + experssion + " ");
System.out.println("运算结果 = " + executeResult);



再次感谢楼主加分，如果需要扩展加入‘’‘]’
这时需要在我的两个类中加入相应条件语句和合理的
if判断OK 参考技术A java.util.Stack就是一个栈容器啊，你用它就行了别。
好好看看这个容器的API吧。
写程序主是一个把思想实现成程序的过程，我建议你还是自己完成代码。我给你一些提示吧。
为了简单，你可以把这个栈定义为一个字符串的栈。把（，a,+,b,)这些元素以String的形式压入。弹出的时候先判断是否是(,),+,-的运算符号（在编译原理中，括号也是一种运算符），如果不是就用Integer.parseInt(String s)来转换数字。你知道思想应该不难

Java多进程管道通信

任务：
设计一个父进程，三个子进程(A,B,C)。子进程A,B同时被父进程启动来计算（不实现具体的计算任务，先用CPU空跑来代替）。进程A计算5分钟，而进程B计算8分钟。当进程A,B都计算完成后才能启动进程C，进程C计算3分钟。

Java中的管道：
Java程序中可以启动其他的应用程序，这种在Java中启动的进程称为子进程，启动子进程的Java程序称为父进程，其实这个父进程就是一个Java虚拟机。在Java程序中可以用Process类的实例对象来表示子进程，子进程的标准输入和输出不在连接到键盘和显示器（也就是不再接收键盘输入，和显示器输出），而是以管道流的形式连接到父进程的一个输出流和输入流对象上。
调用Process类的getOutputStream和getInputStream方法可以获得连接到子进程的输出流和输入流对象。子进程从标准输入读到的内容就是父进程通过输出流对象写入到它们俩之间的进程管道中的数据，子进程写入的标准输出的数据通过它们之间的进程管道传递到了父进程的输入流对象中，父进程从这个输入流对象中读取到的内容就是子进程写入到标准输出的数据编程实例。

1. 思路：
   a) 建立A B C三个类文件，空跑模拟进程运行。
   b) 在父进程中通过Runtime.exec()启动各子进程。
   c) 子进程与父进程的通信通过上述管道实现，子进程完成后发出一个信息，父进程通过接收线程不断接收信息并判断子进程是否完成并决定下一进程启动与否。

2. 代码：
   Father.java
   import java.io.*;
   class Father implements Runnable {
   //获取子进程的对象
   Process p = null;
   Process q = null;
   Process r = null;
   public Father() throws Exception {
   //启动AB进程
   p = Runtime.getRuntime().exec("java A");
   q=Runtime.getRuntime().exec("java B");
   new Thread(this).start();
   }
   //定义接收线程
   public void run() {
   Boolean f=true;
   try{
   InputStream inp = p.getInputStream();
   InputStream inq = q.getInputStream();
   BufferedReader bfrp = new BufferedReader(new InputStreamReader(inp));
   BufferedReader bfrq = new BufferedReader(new InputStreamReader(inq));
   while(f) {
   String str=bfrp.readLine();
   String str1=bfrq.readLine();
   //判断进程是否完成
   if(str.equals("1")&&str1.equals("1")){
   System.out.println("AB");
   r=Runtime.getRuntime().exec("java C");
   InputStream inr = r.getInputStream();
   BufferedReader bfrr = new BufferedReader(new InputStreamReader(inr));
   String str2=bfrr.readLine();
   if (str2!=null&&str2.equals("1"))
   {
   System.out.println("C");
   f=false;
   }
   }
   }
   } catch(Exception e) {
   e.printStackTrace();
   }
   }
   public static void main(String args[]) throws Exception {
   Father f = new Father();
   }
   }
   //进程A
   A. Java
   public class A {
   public static void main(String args[]) {
   int i=0;
   while(true) {
   try{
   Thread.sleep(1000);
   i++;
   if(i==30) {
   System.out.println("1");
   }
   if(i>30)
   break;
   } catch(Exception e) {
   e.printStackTrace();
   }
   }
   }
   }
   //进程B
   B. Java
   public class B {
   public static void main(String args[]) {
   int i=0;
   while(true) {
   try{
   Thread.sleep(1000);
   i++;
   if(i==48) {
   System.out.println("1");
   }
   if(i>48){
   break;
   }
   } catch(Exception e) {
   e.printStackTrace();
   }
   }
   }
   }
   //进程C
   C. Java
   public class C {
   public static void main(String args[]) {
   int i=0;
   while(true) {
   try{
   Thread.sleep(1000);
   i++;
   if(i==18) {
   System.out.println("1");
   }
   if(i>18){
   break;
   }
   } catch(Exception e) {
   e.printStackTrace();
   }
   }
   }
   }