数据结构复习（栈队列一）实现前序、后序、中序表达式的互相转化及构建二叉树（代码实现）

最新推荐文章于 2022-10-24 10:45:22 发布
最新推荐文章于 2022-10-24 10:45:22 发布
阅读量526 收藏 2
点赞数
分类专栏： 算法数据结构 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44861675/article/details/120589687
版权

文章目录

栈和队列一（）

1、类型

  • 最大栈
  • 最小栈
  • 流式数据的最小值
  • 单调队列
  • 两个栈实现一个队列
  • 栈的前缀后缀表达式求值
  • 栈的出栈序列判断
  • 其他

2、基本应用

1） 150. 逆波兰表达式求值 后缀表达式求值

波兰表达式计算 > 输入: ["2", "1", "+", "3", "*"] > 输出: 9

解释: ((2 + 1) * 3) = 9

学栈的时候，我们需要两个栈，一个是符号栈，一个是操作数栈，（）需要去除。

import java.util.Stack;
class Solution {
    //后缀表达式求值
    public int evalRPN(String[] tokens) {
        Stack<Integer> s = new Stack<>();

        for(String s1:tokens){
            if(s1.equals("+")||s1.equals("-")||s1.equals("/")||s1.equals("*")){
                int a = s.pop();
                int b = s.pop();
                if(s1.equals("+")){
                    s.push(b+a);
                }else if(s1.equals("-")){
                    s.push(b-a);
                }else if(s1.equals("*")){
                    s.push(b*a);
                }else{
                    s.push(b/a);
                }
            }
            else
            //这个整数进栈
                s.push(Integer.parseInt(s1));
        }
        //最后一个数
        return s.pop();
    }
}

做完这道题，我们先来回顾以下相关知识点。（图解），这里代码实现了如下内容：

3、实现前序、后序、中序表达式的互相转化及构建二叉树（代码实现）

方法讲解参考：

https://blog.csdn.net/walkerkalr/article/details/22798365

在这里插入图片描述

/**
 * @author 60417
 * @date 2021/10/1
 * @time 9:56
 * @todo
 */
package Stack;

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.util.Stack;

/**
 * 利用stack实现：
 * 1、前缀表达式转后缀表达式
 *      ----前缀表达式求值
 * 2、中缀表达式转后缀表达式
 *      ----中缀表达式求值
 * 3、后缀表达式求值
 *      ----后缀表达式求值
 * 4、中缀表达式转为一颗二叉树   特点：叶子节点是操作数，其他节点为操作符
 *
 * 概念介绍和复习：
 * 前缀表达式 是一种没有括号的算术 表达式 ，与 中缀表达式 不同的是，其将运算符写在前面，操作数写在后面。
 * 后缀表达式 则是将操作数写在前面，运算符写在后面。
 *
 * 前缀表达式 又称波兰 表达式 ，后缀表达式 又称逆波兰 表达式 。
 *
 * 二叉树的三种遍历方式对应了上述三种表达式
 *
 */
public class HouZhui_QianZui_MidZhui {
    public static void main(String[] args) {
        //  1+((2/3)*4)-5*6-9*10-6 = 1+0.66*4-30-90-6=1+2.64-126=122.33333...
        String[] mid = {"1","+", "(","(","2","/", "3",")","*","4",
                ")", "-" ,"5","*","6","-","9","*","10","-","6"};
//        String[] mid = new String[]{"(","2","+","5",")","*","3","+","1"};
        System.out.println("中缀表达式");
        printStringArray(mid);
        String[] strings = MidZhuiToHouZhui(mid);
        System.out.println("后缀表达式");
        printStringArray(strings);
        double v = CountHouZhui(strings);
        System.out.println(v);
        String[] strings1 = MidZuiToQianZhui(mid);
        System.out.println("前缀表达式");
        printStringArray(strings1);
        double v1 = CountQianZhui(strings1);
        System.out.println(v1);

        System.out.println(CountMidZhui(mid));
        System.out.println("==================后缀转中缀====================");
        //后缀转中缀
        System.out.println("后缀逆序为中缀");
        printStringArray(strings);//后缀
        String[] strings2 = HouZhuiToMid(strings);
        printStringArray(strings2);

        System.out.println("格式化完毕");
        //利用转化的中缀再反过来计算一次看以下对不：
        System.out.println("计算后缀：");
        String[] strings3 = MidZhuiToHouZhui(strings2);//转后缀：这里因为没有添加好=号分割除每一个符号所以有点难难计算
        System.out.println("转化的后缀表达式：");
        printStringArray(strings3);
        System.out.println("计算前缀");
        String[] strings4 = MidZuiToQianZhui(strings2);
        System.out.println("转化的前缀表达式：");
        printStringArray(strings4);

        System.out.println("计算每一种表达式的值");
        System.out.println(CountQianZhui(strings4));
        System.out.println(CountHouZhui(strings3));
        System.out.println(CountMidZhui(strings2));


        System.out.println("======后缀表达式构造二叉树=======");//strings
        TreeNode treeNode = constructTreeByMinZhui(strings);
        treeNode.traver(0);
        treeNode.traver(1);
        treeNode.traver(2);




    }

    /**
     * 工具函数，打印字符数组
     * @param token
     */
    public static void printStringArray(String[] token){
        if(token==null || token.length==0){
            System.out.print("null");
            return;
        }
        for(String s:token){
            System.out.print(s);
        }
        System.out.println();
    }
    /**
     * 返回算法符号的优先级：
     * 基本符号 + - * /
     * 括号: ()
     * @param operator
     * @return
     */
    public static int priority(String operator){
        if(operator==null || operator.length()>=2){
            return -1;//不存在的优先级
        }
        int priority = -1;
        switch (operator){
            case "*":
            case "/":priority = 2;break;
            case "+":
            case "-":priority = 1;break;
            case "(":
            case ")":priority = 0;break;
            default: break;
        }
        return priority;
    }
    /**
     * 后缀表达式 转中缀表达式
     * @param tokens 输入的合法 前缀表达式
     * @return 后缀表达式
     */
    public static String[] HouZhuiToMid(String[] tokens){
        //根据后缀表达式求值的过程就是一个中缀表达式的计算过程，只不过去除了括号，我们可以手动添加：
        //前缀表达式和后缀表达式的区别就是需要逆序遍历，然后操作数
        //遍历每个字符，数字就入栈，运算符则弹出两个操作数，对应右操作数和左操作数，运算结果 入栈：
        System.out.println("后缀转中缀表达式");
        Stack<String> stack = new Stack<>();
        for(String s:tokens){
            if("".equals(s)||s==null){
                continue;
            }
            //判断是符号还是数子：
            if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")")){
                String a1 = stack.pop();//操作数
                String a2 = stack.pop();
                switch (s){
                    case "+":stack.push("(="+a2+"=+="+a1+"=)=");break;  //  插入(a2+a1)
                    case "/":stack.push(a2+"=/="+a1+"=");break;
                    case "*":stack.push(a2+"=*="+a1+"=");break;
                    case "-":stack.push("(="+a2+"=-="+a1+"=)=");break;//=用来分割
                }
            }else {//后缀直接插入
                stack.push(s+"=");
            }
        }
        StringBuilder s = new StringBuilder();
        while(!stack.isEmpty()){
            s.append(stack.pop());
        }
        String[] split = s.toString().split("=");
        StringBuilder s2 = new StringBuilder();
        int i=0;
        for(String temp :split){
            if(!"".equals(temp)){
                s2.append(temp);
                s2.append("=");

            }
        }
        return s2.toString().split("=");

    }


    /**
     * 中缀转前缀   从右往左扫描，使得符号位于操作数前面（通过追加字符串然后翻转）
     * @param tokens
     * @return
     */
    public static String[] MidZuiToQianZhui(String[] tokens){
        //前缀表达式和后缀表达式的区别就是需要逆序遍历，然后操作数
        StringBuilder hou_tokens = new StringBuilder();//表达式，使用=分割每个符号和操作数
        Stack<String> stack = new Stack<>();//存储符号
        for(int i=tokens.length-1;i>=0;i--){
            String s = tokens[i];//从后面扫描
            //判断是符号还是数字：
            if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")")){
                if(stack.isEmpty()){
                    stack.push(s);
                }else{
                    if(s.equals(")")){//这里
                        stack.push(s);
                        continue;
                    }
                    String peek = stack.peek();
                    int peek1 = priority(peek);//栈顶符号优先级
                    int s1 = priority(s);//当前符号优先级

                    if(s1>=peek1){//当前符号大于等于栈顶符号，入栈
                        stack.push(s);
                    }else{
                        //取出当前符号
                        //判断是不是“)”
                        if(s.equals("(")){//需要不断弹栈直到遇到“）”
                            //因为我们这里的表达式是合法的 所以不判空了
                            while(!stack.peek().equals(")")){
                                hou_tokens.append(stack.pop());
                                hou_tokens.append("=");
                            }
                            //此时stack.peek()==")"
                            stack.pop();
                        }else{
                            //s1<=peek1  不是）  则需要把栈顶元素弹出到末尾：
                            while(!stack.isEmpty() &&  priority(stack.peek())>s1){
                                hou_tokens.append(stack.pop());
                                hou_tokens.append("=");
                            }
                            stack.push(s);
                        }
                    }
                }

            }else {
                //数字：直接输出
                hou_tokens.append(s);
                hou_tokens.append("=");//=号分隔
            }
        }
        while (!stack.isEmpty()){
            hou_tokens.append(stack.pop());
            hou_tokens.append("=");
        }
//        System.out.println();
//        System.out.println("转化后的=分割表达式");
//        System.out.println(hou_tokens);
        //这里需要翻转 这里需要注意，如果是个位数的逆序没有问题，但是如果是10 逆序变为了01错误了
//        return hou_tokens.reverse().toString().split("=");
        String[] split = hou_tokens.toString().split("=");
        String[] s = new String[split.length];
        int c=0;
        for(int i=split.length-1;i>=0;i--){
            s[c++] = split[i];
        }
        return s;
    }

    /**
     * 中缀表达式转后缀表达式   扫描方式从左到右，进而符号位于操作数的后面
     * @param tokens 输入的合法 前缀表达式
     * @return 后缀表达式
     */
    public static String[] MidZhuiToHouZhui(String[] tokens){
        //前缀表达式和后缀表达式的区别就是需要逆序遍历，然后操作数
        StringBuilder hou_tokens = new StringBuilder();//表达式，使用=分割每个符号和操作数
        Stack<String> stack = new Stack<>();//存储符号
        for(String s:tokens){
            //判断是符号还是数子：
            if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")")){
                if(stack.isEmpty()){
                    stack.push(s);
                }else{
                    if(s.equals("(")){
                        stack.push(s);
                        continue;
                    }
                    String peek = stack.peek();
                    int peek1 = priority(peek);//栈顶符号优先级
                    int s1 = priority(s);//当前符号优先级

                    if(s1>peek1){//当前符号大于栈顶符号，入栈 同级呢？
                        stack.push(s);
                    }else{
                        //取出当前符号
                        //判断是不是“)”
                        if(s.equals(")")){//需要不断弹栈直到遇到“）”
                            //因为我们这里的表达式是合法的 所以不判空了
                            while(!stack.peek().equals("(")){
                                hou_tokens.append(stack.pop());
                                hou_tokens.append("=");
                            }
                            //此时stack.peek()=="("
                            stack.pop();
                        }else{
                           //一直弹，直到栈顶符号优先级小于s1
                            while(!stack.isEmpty() &&  priority(stack.peek())>=s1){
                                hou_tokens.append(stack.pop());
                                hou_tokens.append("=");
                            }
                            stack.push(s);

                        }
                    }
                }

            }else {
                //数字：直接输出
                hou_tokens.append(s);
                hou_tokens.append("=");//=号分隔
            }
        }
        while (!stack.isEmpty()){
            hou_tokens.append(stack.pop());
            hou_tokens.append("=");
        }
        return hou_tokens.toString().split("=");
    }

    /**
     * 后缀表达式 求值
     * @param tokens 输入的合法 后缀表达式
     * @return 结果
     */
    public static double CountHouZhui(String[] tokens){
        //前缀表达式和后缀表达式的区别就是需要逆序遍历，然后操作数
        //遍历每个字符，数字就入栈，运算符则弹出两个操作数，对应右操作数和左操作数，运算结果 入栈：
        Stack<Double> stack = new Stack<>();
        System.out.println("计算后缀表达式");
        printStringArray(tokens);
        for(String s:tokens){
            if("".equals(s)||s==null){
                continue;
            }
            //判断是符号还是数子：
            if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")")){
                double a1 = stack.pop();
                double a2 = stack.pop();
                switch (s){
                    case "+":stack.push(a2+a1);break;
                    case "/":stack.push(a2/a1);break;
                    case "*":stack.push(a2*a1);break;
                    case "-":stack.push(a2-a1);break;
                }
            }else {
                stack.push((double) Integer.parseInt(s));
            }
        }
        return stack.pop();

    }
    /**
     * 前缀表达式 求值
     * @param tokens 输入的合法 前缀表达式
     * @return 结果
     */
    public static double CountQianZhui(String[] tokens){
        //前缀表达式和后缀表达式的区别就是需要逆序遍历，然后操作数
        Stack<Double> stack = new Stack<>();
        System.out.println("计算前缀表达式");
        printStringArray(tokens);
        for(int i=tokens.length-1;i>=0;i--){//
            String s = tokens[i];
            if("".equals(s)||s==null){
                continue;
            }
            //判断是符号还是数子：
            if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")")){
                double a2 = stack.pop();//这里，a1和a2对应的位置
                double a1 = stack.pop();
                switch (s){
                    case "+":stack.push(a2+a1);break;
                    case "/":stack.push(a2/a1);break;
                    case "*":stack.push(a2*a1);break;
                    case "-":stack.push(a2-a1);break;
                }
            }else {
                stack.push((double) Integer.parseInt(s));
            }
        }
        return stack.pop();
    }
    /**
     * 中缀表达式 求值
     * @param tokens 输入的合法 前缀表达式
     * @return 结果
     */
    public static double CountMidZhui(String[] tokens){
        //中缀表达式就是先转为后缀表达式再计算：
        System.out.println("计算中缀表达式 转化后缀表达式再计算");
        printStringArray(tokens);
        String[] strings = MidZhuiToHouZhui(tokens);
        return  CountHouZhui(strings);
    }

    /**
     * 根据后缀表达式构建中缀表达式树：
     */
    public static TreeNode constructTreeByMinZhui(String[] tokens){
//        在遍历到操作数时建立新节点并将该节点压入操作数栈中。
//        当操作符从操作符栈中出栈时为该操作符新建一个节点，并从操作数栈中pop出两个操作数节点，
//        将第一个操作数节点作为新节点的右节点，第二个个作为左节点，之后将这个新节点压入操作数栈中。
//        当最后一个操作符出栈时，就构成了二叉树，且最后一个操作符节点为根节点。

            if(tokens==null||tokens.length==0){
                return null;
            }
            System.out.println("构建树");
            printStringArray(tokens);
            Stack<TreeNode> stack = new Stack<>();//栈

            for(String s:tokens){
                //判断是符号还是数子：
                if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")")){
                   //操作符：
                    if(s.equals("(") ||s.equals(")")){
                        continue;
                    }
                    TreeNode treeNode = new TreeNode(s);
                    treeNode.right = stack.pop();//第一个弹出的是右孩子
                    treeNode.left = stack.pop();
                    stack.push(treeNode);
                }else {//数字，则构建节点，进栈
                    stack.push(new TreeNode(s));
                }
            }
//            while (stack.isEmpty()){
//                if(stack.size()==1){
//                    return stack.pop();
//                }else {
//                    TreeNode right = stack.pop();
//                    TreeNode left = stack.pop();
//                    return null;
//
//                }
//            }
        return stack.pop();



    }
    static class TreeNode {
        String val;//节点的值：
        TreeNode left;
        TreeNode right;

        public TreeNode(String val) {
            this.val = val;
        }

        public TreeNode(String val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
        public void traver(int i){//遍历二叉树，0前序遍历，1中序遍历，2后序遍历
            if(i==0){
                System.out.println("前序遍历");
                preTraver(this);
                System.out.println();
            }
            else if(i==1){
                System.out.println("中序遍历");
                midTraver(this);
                System.out.println();
            }else if(i==2){
                System.out.println("后续遍历");
                postTraver(this);
                System.out.println();
            }else {
                throw new RuntimeException("不支持的参数！");
            }
        }

        private void postTraver(TreeNode root) {
            if(root==null){
                return;
            }
            postTraver(root.left);
            postTraver(root.right);
            System.out.print(root.val+" ");
        }

        private void midTraver(TreeNode root) {
            if(root==null){
                return;
            }
            midTraver(root.left);
            System.out.print(root.val+" ");
            midTraver(root.right);
        }

        private void preTraver(TreeNode root) {
            if(root==null){
                return;
            }
            System.out.print(root.val+" ");
            preTraver(root.left);
            preTraver(root.right);
        }
    }
}

例子演示：

在这里插入图片描述

构建树：这里只实现了后序表达式构建树：

在这里插入图片描述

代码可能有错误，因为没有经过大量用例测试

雨夜※繁华
关注
专栏目录
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
数据结构与算法知识要点简明教程（合集）
编程之路
07-23 2330
参考：https://blog.csdn.net/jiaoyangwm/article/details/80808235 本文仅是将他人博客经个人理解转化为简明的知识点，供各位博友快速理解记忆，并非纯原创博客，如需了解详细知识点，请查看参考的各个原创博客。 ...
用堆栈实现中序转前序
11-06
用堆栈实现中序转前序，有具体输出过程，我看到网上也有这类的代码，但是不能成功执行，故传一个上去
前序、中序和后序表达式转换问题
moodfriend的博客
10-24 1080
以A + B * C为例，操作数 A 、B 和 C 的相对位置保持不变，只有运算符改变了位置。再观察中序表达式中的运算符。但是在后序表达式中，由于 * 的优先级更高（写成完全括号表达式后乘法所在的括号先进行运算），因此 * 先于 + 出现，前序表达式与后序表达式相反。答案是，这两种表达式中的运算符所对应的操作数是明确的。从这个表格中可以看到中序表达式和前序表达式、后序表达式的区别，中序表达式有括号，前序和后序没有括号。（1）反转输入字符串，如“(A+B)*(C+D)” 反转后为“(D+C)*(B+A)”。
前、中、后序表达式及其转化
m0_60492395的博客
09-05 1404
中序表达式的转化
前、中、后缀表达式概述及转换+栈的计算器原理及代码分析(含完整源码)
记录博主学到的点滴
06-07 1342
目录: 1.前中后缀表达式的概述及相互转换 2 3. 4. 5. 1.前中后缀表达式的概述及相互转换 1.1前中后缀表达式的概述 前缀表达式：运算符位于操作数之前。 中缀表达式（波兰式）：首先前中后缀表达式，一般正常写的(2*4-1)+5-6这种式子称为中缀表达式。 后缀表达式（逆波兰式）：运算符位于操作数之前。 前缀和后缀表达式中是不含括号的 1.2中缀表达式转前后缀表达式 首先 2. 3. 4. 5. 6. 7. 8. 9. ...
二叉树实现中序表达式转换后序表达式
12-25
原创，用二叉树的非线性结构实现中序表达式转为后序表示的算法，代码简单易懂，解决了用栈来转换的复杂性，及拜托必须用括号来解决操作符优先级的麻烦。
期末数据结构复习资料合集
7. 树和二叉树（6-1、树和二叉树.pptx）：这部分内容是对树和二叉树概念的复习和深化，包括树的定义、性质、基本术语、遍历算法（前序、中序、后序和层序遍历）等。 8. 栈和队列（4、栈和队列.pptx）：栈是一种后进...
828数据结构与操作系统复习大纲.pdf
03-11
- **树**：理解和掌握二叉树的定义、性质、表示方法和遍历算法，包括前序、中序和后序遍历。学习线索二叉树的构造和结点的插入、删除，以及哈夫曼树的构建和编码，表达式树的应用。 - **图**：了解图的逻辑结构和...
历年机试题大数据分析1
08-04
学习树的性质、遍历方法（如前序、中序、后序）以及树的构建与操作是解决这类问题的基础，如二叉树、平衡树、B树、红黑树等。 6. **图问题**：虽然只出现1次，但结合树问题的趋势，复习图论是必要的。图的遍历...
数据结构 C 代码 6.x: 自己建栈实现二叉树遍历
minfanphd的博客
05-27 498
本贴为《数据结构》课程服务. 1. 主要内容 二叉树的先序、中序、后序遍历. 不准用递归. 2. 代码 2.1 潘佳豪 自己写队列, 真-不偷懒. 后序遍历有复杂的条件, 还有 while 循环的嵌套, 功力深厚. 居然还用文本在程序里画一棵树, 必成大器啊! #include <iostream> #include <malloc.h> using namespace std; #define MAXSIZE 1000 typedef int ElemType; typ
使用栈的二叉树前序与中序遍历
张驴儿的博客
03-15 4132
使用栈的二叉树前序与中序遍历 使用栈的前序与后序遍历比较简单，只不过改变输出位置。但是原理是要清楚的。 template struct BiNode { T data; BiNode* lchild, *rchild; }; template void BiTree::UnReCurPreOrder(BiNode* bt) { printf("非递归前序遍历："); if (null
前序、中序、后序表达式的相互转换问题
snowstorm的博客
08-18 1万+
这是一个常考的问题，现在总结一下： 一、前序表达式转换为中序表达式： 从右往左开始，取出一个操作符和操作符右边的两个数进行计算，并将计算的结果放过去，直到计算结束。以前序表达式“+/*23-21*3-41”为例，将其转换为中序表达式： （1）取出“-”、4、1，计算并将结果放回得到“+/*23-21*3(4-1)”； （2）取出“*”、3、(4-1)，计算并将结果放回得到“+/*23-21
二叉树 前序转中序表达式
zhulefei的专栏
10-19 826
网上找半天都没找着一个像样的，所以自己动手写了一个  import java.util.Scanner;public class TreeExpress{ private int index; class Node{  Node Left;  Node Right;  String str; }  public static void main(String args[]){  Sca
前缀表达式转中缀中缀表达式
qq_34450601的博客
07-12 6102
import java.util.Scanner; import java.util.Stack; public class test { static String e; static Scanner scan; static String[] sarray1; static String a = ""; public static void main(String[] args) ...
中序表达式转为后序表达式（c语言）
计算机科学与技术专业学生的成长之路
09-03 4236
按照中序表达式与后序表达式的规则借助堆栈进行表示即可（后附详细链接二叉运算树）） 中序表达式就是我们在数学中见到的中规中矩的表达式，例如3+2-(2*3-7);后序表达式满足运算符号置于数字的后面； 在转化的过程中满足的规则： 若优先级大于栈顶的运算符，那么把它压入栈‘ 若优先级小于等于栈顶的运算符，将堆栈中的所有大于等于它的运算符全部输出，并且将该运算符放入堆栈中； 若各个对象处理完毕，则...
数据结构-栈-中缀、后缀、前缀相互转换
乘梦碧溪的博客
10-20 1149
中缀：正常表达式 后缀：逆波兰式 1、栈中存符号 2、字母、数字直接打印 3、先进栈，再比较优先级，只有当比栈中前一个符号优先级高的情况下才走下去，否则弹出前一个符号，直至前一个符号的优先级小于这个符号，也即是连续弹栈。 4、打印的时候遇到括号不计在内，但是在栈中括号是被存储过的，当遇到）时，按照“先进后出”的原则弹...
(栈的应用)中序表达式转换成后序表达式问题
暴走的山交君的博客
12-04 1380
中序表达转换成后序表达式的方法： 从左到右读取该中弱序表达式： 1.若是操作数，则直接输出. 2.若是运算符： (1)若该运算符为"(",则直接入栈. (2)若该运算符为")",则取出堆栈中的运算符，直到"("时. (3)其它： 按优先级比较，如果大于或等于堆栈中当前的运算则压入栈中，否则直接输出. (4)检查栈是否非空，如果非空，则输出所有值，直到空为止. *、/、%的优先级当然比+、－高了 例如：中序表达式(23+34*45/(5+6+7))转换成后序表达式23 34 45 * 5 6
二叉树应用——后缀表达式构建表达式树
热门推荐
奋斗的程序猿的博客
09-05 2万+
针对前一篇博文后缀表达式求值、中缀表达式到后缀表达式的转换，已经可以实现中缀表达式到后缀表达式的转换，这里再介绍根据后缀表达式构建表达式树，那我们就能够从这两种常用类型的输入表达式（中缀和后缀）生成表达式树。
c语言实现建立一棵二叉树，并实现前序、中序和后序遍历这棵二叉树并写出代码
最新发布
04-11
非常感谢您的提问。以下是C语言实现建立一棵二叉树，并实现前序、中序和后序遍历这棵二叉树的代码： #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *left; struct Node *right; } Node; Node* newNode(int data) { Node* node = (Node*)malloc(sizeof(Node)); node->data = data; node->left = NULL; node->right = NULL; return(node); } void printPreorder(Node* node) { if (node == NULL) return; printf("%d ", node->data); printPreorder(node->left); printPreorder(node->right); } void printInorder(Node* node) { if (node == NULL) return; printInorder(node->left); printf("%d ", node->data); printInorder(node->right); } void printPostorder(Node* node) { if (node == NULL) return; printPostorder(node->left); printPostorder(node->right); printf("%d ", node->data); } void main() { Node *root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); printf("\nPreorder traversal of binary tree is \n"); printPreorder(root); printf("\nInorder traversal of binary tree is \n"); printInorder(root); printf("\nPostorder traversal of binary tree is \n"); printPostorder(root); } 请注意，由于技术限制，我无法编写代码。所以以上代码仅供参考。谢谢！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨夜※繁华

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

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

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

打赏作者

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

抵扣说明：

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

余额充值