数据结构与算法（三）栈

最新推荐文章于 2022-07-06 17:21:55 发布
最新推荐文章于 2022-07-06 17:21:55 发布
阅读量472 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46161565/article/details/121938408
版权
1、栈的介绍

(1)栈(stack)是一个先入后出(FILO-First In Last Out)的有序列表

(2)栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表，允许插入和删除的一端为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(bottom)

(3)根据栈的定义可知，最先放入栈中的元素在栈底，最后放入的元素在栈顶，而删除元素正好相反，最后放入的元素最先删除，最先放入的元素最后删除

(4)图解的方式说明入栈(push)和出栈(pop)

2、栈的出栈和入栈

(1)用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作

(2)思路分析

①定义一个 top 来表示栈顶，初始化 为 -1

②入栈的操作，当有数据加入到栈时， top++; stack[top] = data;

③出栈的操作， int value = stack[top]; top–, return value

(3)代码实现

package com.cyk.stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试
        ArrayStack stack = new ArrayStack(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 result = stack.pop();
                        System.out.printf("出栈的数据：%d\n", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出！");
    }
}

//定义一个ArrayStack类表示栈结构
class ArrayStack {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈，栈的数据存放在数组中
    private int top = -1;//表示栈顶，初始化为-1

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

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

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

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

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空！");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈，遍历时，需要从栈顶开始显示
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据！");
            return;
        }

        //需要从栈顶开始显示
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}
3、栈实现综合计算器(中缀表达式)

(1)使用栈来实现综合计算器

(2)思路分析

使用栈完成表达式的计算思路

①通过一个 index 值(索引)，来遍历我们的表达式

②如果我们发现是一个数字，就直接入数栈

③如果发现扫描到是一个符号, 就分如下情况

​ 3.1 如果发现当前的符号栈为空，就直接入栈

​ 3.2 如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算，将得到结果入数栈，然后将当前的操作符入符号栈， 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈

④当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行

⑤最后在数栈只有一个数字，就是表达式的结果

(3)代码实现：先实现一位数的运算，再扩展到多位数的运算

package com.cyk.stack;

public class Calculator {
    public static void main(String[] args) {
        //测试
        String exp = "7*2*2-5+1-5+3-4";
        //创建两个栈，一个是数字栈，一个是符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operationStack = new ArrayStack2(10);

        //定义需要的相关变量
        int index = 0;//用于扫描
        int num1 = 0;
        int num2 = 0;
        int operation = 0;
        int result = 0;
        char ch = ' ';//将每次扫描得到的char保存到ch中
        String keepNum = "";//用于拼接多位数

        //循环扫描exp
        while (true) {
            ch = exp.substring(index, index + 1).charAt(0);
            //判断ch是什么，然后做相应的处理
            if (operationStack.isOperation(ch)) {//是运算符
                //判断当前的符号栈是否为空
                if (!operationStack.isEmpty()) {
                    //如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数
                    //再从符号栈中pop出一个符号，进行运算，将得到的结果入数字栈，然后将当前的操作入符号栈
                    if (operationStack.priority(ch) <= operationStack.priority(operationStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        operation = operationStack.pop();
                        result = numStack.calculate(num1, num2, operation);
                        //把运算的结果入数字栈
                        numStack.push(result);
                        //把当前的运算符入符号栈
                        operationStack.push(ch);
                    } else {
                        //如果当前运算符的优先级大于战中的操作符，直接入栈
                        operationStack.push(ch);
                    }
                } else {
                    //如果为空，直接入符号栈
                    operationStack.push(ch);
                }
            } else {//是数字，直接入数字栈
                //numStack.push(ch - 48);
                //分析思路
                //1.当处理多位数时，不能发现是一个数就立即入栈，因为它可能时多位数
                //2.在处理数时，需要向exp的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个变量字符串，用于拼接
                keepNum += ch;

                //如果ch是exp的最后一位，则直接入栈
                if (index == exp.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {
                    //判断下一个字符是不是数字，如果是数字，则继续扫描
                    if (operationStack.isOperation(exp.substring(index + 1, index + 2).charAt(0))) {
                        //后一位是运算符，入栈
                        numStack.push(Integer.parseInt(keepNum));
                        //将keepNum清空，非常重要！！！！！！
                        keepNum = "";
                    }
                }
            }
            //让index + 1 ，判断是否扫描到exp的最后
            index++;
            if (index >= exp.length()) {
                break;
            }
        }
        //当表达式扫描完毕，就顺序地从数字栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字（就是结果）
            if (operationStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            operation = operationStack.pop();
            result = numStack.calculate(num1, num2, operation);
            //把运算的结果入数字栈
            numStack.push(result);
        }
        //将数栈的最后一个数pop
        System.out.printf("表达式为：%s = %d", exp, numStack.pop());

    }
}

//定义一个ArrayStack2类表示栈结构，需要扩展功能
class ArrayStack2 {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈，栈的数据存放在数组中
    private int top = -1;//表示栈顶，初始化为-1

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

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

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

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

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空！");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈，遍历时，需要从栈顶开始显示
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据！");
            return;
        }

        //需要从栈顶开始显示
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    //返回运算符的优先级，优先级使用数字表示，数字越大，优先级越高
    public int priority(int operation) {
        if (operation == '*' || operation == '/') {
            return 1;
        } else if (operation == '+' || operation == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    //判断是不是一个运算符
    public Boolean isOperation(char value) {
        return value == '+' || value == '-' || value == '*' || value == '/';
    }

    //计算方法
    public int calculate(int num1, int num2, int operation) {
        int result = 0;//用于存放计算结果
        switch (operation) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num2 - num1;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                result = num2 / num1;
                break;
            default:
                break;
        }
        return result;
    }

    //获得当前栈顶的数据，不是出栈
    public int peek() {
        return stack[top];
    }
}
4、中缀表达式转为后缀表达式

1、具体步骤如下

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

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

(3)遇到操作数时，将其压入s2

(4)遇到运算符时，比较其与s1栈顶运算符的优先级：

​ 4.1如果s1为空，或栈顶运算符为左括号 “(” ，则直接将此运算符入s1栈

​ 4.2否则，若优先级比栈顶运算符的高，也将运算符压入s1栈

​ 4.3否则，将s1栈顶的运算符弹出并压入到s2中，再次转到4.1的步骤，与s1中新的栈顶运算符相比较

(5)遇到括号时：

​ 5.1如果是左括号 “(” ，则直接压入s1

​ 5.2如果是右括号 “)” ，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃

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

(7)将s1中剩余的运算符依次弹出并压入s2

(8)依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

2、举例说明

将中缀表达式：1+((2+3)*4)-5 转换为后缀表达式的过程如下

因此结果为：1 2 3 + 4 * + 5 -

3、代码实现

//将中缀表达式转成对应的List
public static List<String> toInfixExpList(String s) {
    //定义一个List，存放中缀表达式对应的内容
    List<String> list = new ArrayList<String>();
    int i = 0;//这是一个指针，用于遍历中缀表达式字符串
    String str;//对多位数的拼接
    char c;//每遍历到一个字符，就放入到c中
    do {
    //如果c是一个非数字，需要加入到list中
    if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
    	list.add("" + c);
    	i++;//i后移
    } else {//如果是一个数（需要考虑多位数）
    	str = "";//先将str置为空
    	while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
    		str += c;//拼接
    		i++;
    	}
    	list.add(str);
    }

    } while (i < s.length());
        return list;
}

//将中缀表达式对应的list转换成后缀表达式对应的list
public static List<String> parseSuffixExpList(List<String> ls) {
    //定义两个栈
    Stack<String> s1 = new Stack<>();//符号栈
    //Stack<String> s2 = new Stack<String>();//储存中间结果的栈s2
    //说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
    //因此比较麻烦，这里我们就不用Stack<String>，而是直接使用List<String> s2
    ArrayList<String> s2 = new ArrayList<>();//储存中间结果的list s2

    //遍历ls
    for (String item : ls) {
    //如果是一个数，加入到s2
    if (item.matches("\\d+")) {
    	s2.add(item);
    } else if (item.equals("(")) {
    	//如果是左括号
    	s1.push(item);
    } else if (item.equals(")")) {
    	//如果是右括号，则依次弹出s1栈顶的运算符，直到遇到左括号为止，此时将这一对括号丢弃
    	while (!s1.peek().equals("(")) {
    		s2.add(s1.pop());
    	}
    	s1.pop();//将左括号弹出s1栈，消除小括号
    } else {
    	//当item的优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并加入到s2中，再次转到（4.1）步骤与s1中新的栈顶运算符相比较
    	while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
    		s2.add(s1.pop());
    	}
    	//还需要将item压入栈
    	s1.push(item);
        }
    }

    //将s1中剩余的运算符依次弹出并加入到s2中
    while (s1.size() != 0) {
    	s2.add(s1.pop());
    }
    return s2;//因为是存放到List，因此按顺序输出就是对应的后缀表达式对应的List
}
5、逆波兰计算器(非完整版)

1、要求

(1)输入一个逆波兰表达式(后缀表达式)，使用栈(stack)，计算其结果

(2)支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此对计算器进行简化，只支持对整数的计算

2、思路分析

例如：(3+4)*5-6对应的后缀表达式就是 3 4 + 5 * 6 -

(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，由此得出最终的结果

3、代码实现

package com.cyk.stack;

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

public class PolandNotation {
    public static void main(String[] args) {

        //完成将一个中缀表达式转成后缀表达式的功能
        //说明：
        //1.1+((2+3)*4)-5转成 1 2 3 + 4 * + 5 -
        //2.因为直接对str进行操作，不方便，因此先将"1+((2+3)*4)-5" =>中缀表达式对应的List
        //即1+((2+3)*4)-5 => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        //3.将中缀表达式对应的list转换成后缀表达式对应的list
        //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  => ArrayList [1,2,3,+,4,*,+,5,–]

        //测试
        List<String> infixExp = toInfixExpList("1+((2+3)*4)-5");
        System.out.println("中缀表达式对应的List：" + infixExp);

        //测试中缀表达式转换成后缀表达式
        List<String> suffixExpList = parseSuffixExpList(infixExp);
        System.out.println("后缀表达式对应的List：" + suffixExpList);

        //测试计算的结果
        System.out.printf("Exp = %d", calculate(suffixExpList));

        //先定义一个逆波兰表达式
        //(3+4)×5-6=>3 4 + 5 * 6 -
//        String suffixExp = "4 5 * 8 - 60 + 8 2 / +";
        //思路：
        //1、先将"3 4 + 5 x 6 -"放到ArrayList中
        //2、将ArrayList传递给一个方法，遍历ArrayList配合栈完成计算

//        List<String> listString = getListString(suffixExp);
//        System.out.println(listString);

        //测试
//        int result = calculate(listString);
//        System.out.println("计算的结果是：" + result);
    }

    //将中缀表达式对应的list转换成后缀表达式对应的list
    public static List<String> parseSuffixExpList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<>();//符号栈
        //Stack<String> s2 = new Stack<String>();//储存中间结果的栈s2
        //说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //因此比较麻烦，这里我们就不用Stack<String>，而是直接使用List<String> s2
        ArrayList<String> s2 = new ArrayList<>();//储存中间结果的list s2

        //遍历ls
        for (String item : ls) {
            //如果是一个数，加入到s2
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                //如果是左括号
                s1.push(item);
            } else if (item.equals(")")) {
                //如果是右括号，则依次弹出s1栈顶的运算符，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//将左括号弹出s1栈，消除小括号
            } else {
                //当item的优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并加入到s2中，再次转到（4.1）步骤与s1中新的栈顶运算符相比较
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);
            }
        }

        //将s1中剩余的运算符依次弹出并加入到s2中
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }
        return s2;//因为是存放到List，因此按顺序输出就是对应的后缀表达式对应的List
    }

    //将中缀表达式转成对应的List
    public static List<String> toInfixExpList(String s) {
        //定义一个List，存放中缀表达式对应的内容
        List<String> list = new ArrayList<String>();
        int i = 0;//这是一个指针，用于遍历中缀表达式字符串
        String str;//对多位数的拼接
        char c;//每遍历到一个字符，就放入到c中
        do {
            //如果c是一个非数字，需要加入到list中
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                list.add("" + c);
                i++;//i后移
            } else {//如果是一个数（需要考虑多位数）
                str = "";//先将str置为空
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                list.add(str);
            }

        } while (i < s.length());
        return list;
    }

    //将一个逆波兰表达式，依次将数据和运算符放入到ArrayList中
    public static List<String> getListString(String suffixExp) {
        //将suffixExp分割
        String[] split = suffixExp.split(" ");
        ArrayList<String> list = new ArrayList<>();
        for (String element : split) {
            list.add(element);
        }
        return list;
    }

    //完成对逆波兰表达式的运算
    /*
    （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 calculate(List<String> list) {
        Stack<String> stack = new Stack<String>();
        //遍历list
        for (String item : list) {
            //这里使用正则表达式来取出数
            if (item.matches("\\d+")) {//匹配的是多位数
                //入栈
                stack.add(item);
            } else {
                //pop出两个数，并计算，再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int result = 0;
                if (item.equals("+")) {
                    result = num1 + num2;
                } else if (item.equals("-")) {
                    result = num1 - num2;
                } else if (item.equals("*")) {
                    result = num1 * num2;
                } else if (item.equals("/")) {
                    result = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //把result入栈
                stack.push(result + "");
            }

        }
        //最后留在stack中的数据就是结果
        return Integer.parseInt(stack.pop());
    }
}

//编写一个类Operation可以返回一个运算符对应的优先级
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //写一个方法，返回对应的优先级的数字
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符！");
                break;
        }
        return result;
    }
}
特雷比西亚的王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【面试题】-模拟实现栈数据结构（先进后出）
Ronychen的博客
01-13 870
要求：并要求实现类的in、out、top、size函数，同时要求，执行下面代码时输出预期结果 class Stack{ constructor(){ } in(value){ // 你的代码 } out(){ // 你的代码 } top(){ // 你的代码 } size(){ // 你的代码 } } const stack = new Stack(); stack.in(1); stack.in(2); stack.in(3); stack.top(); //输出3 stack.
数据结构之栈（Stack）
weixin_49561445的博客
02-23 833
简介 栈是一种线性结构，具有先进后出的特点，即先入栈的最后出栈。删除时刚好相反：最后放入的元素最先删除，最先放入的元素最后删除。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 入栈示意图 出栈示意图 栈是集合Vector的一个子类，它实现了一个标准的后进先出的栈。 堆栈只定义了默认构造函数，用来创建一个空栈。 堆栈除了包括由Vector定义的所有方法，也定义了
数据结构与算法--栈
m0_49513457的博客
05-04 620
栈栈（Stack）用数组模拟栈（结构图如下）用数组模拟栈代码栈实现综合计算器：（运算符优先级自行给出）栈实现综合计算器代码后缀表达式计算后缀表达式计算代码 栈（Stack） * 栈是一个先入后出（FILO-First In Last Out） 的有序列表； * 栈是限制线性表中元素 的插入 与 删除 只能 在线性表的同一端进行的中特殊线性表。其插入与删除一端，称为栈顶（Top），另一端四固定不动的，称之为栈底（Botton）； 栈的应用场景： * 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆
数据结构与算法(四)之栈
qq_38783257的博客
02-06 227
栈简介 栈是一个先入后出(FILO)的有序列表，最先放入的数据在栈底，最后放入的元素在栈顶，最后放入的元素先删除，最先放入的先删除。 栈的实现 public class Stack { private int[] stack; private int top; private int maxSize; public Stack(int maxSize){ ...
数据结构——栈
Yellow_Star的博客
04-11 822
栈 概念 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 通俗来讲，大家可以把栈理解为小时候玩手枪上子弹的玩具，先上进去的子弹是在最下面的，第一个射出的子弹是最后一个上进去的子弹，这就是栈与队列不同的地方：先进后出 思路分析 代码实现
恋上数据结构与算法课件.rar
11-23
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。本课程的资源"恋上数据结构与算法课件.rar"涵盖了多个核心概念，旨在帮助学习者深入理解这些关键领域。 首先，我们来探讨“复杂度”。在计算...
JS数据结构与算法.pdf
最新发布
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
表达式求值（c++，符号栈+数字栈）
GshWooho的博客
03-30 655
问题：输入前缀表达式，输出计算结果 分析： 1.输入：对应infixExp的input函数，要保证能接受多位十进制数，我选用cin.peek()函数，对输入流中的下一个字符先peek，分类讨论，如果是符号，用cin输入一个数；如果是数字，再peek下一个字符，直到符号为止。 存储形式：如果要让符号和数字都在一个vector中存储，就需要自己编写一个类型，可以分别容纳符号和数字，对应MyNum类。 2.前缀转后缀:对应infixExp::toPostfixExp()函数，维护一个符号栈，根据符号的优先级，来维
数据结构与算法——栈
weixin_51699336的博客
09-08 148
栈 基本介绍 <1> 限制性线性表，元素只能在一端插入和删除的特殊线性表 <2> 允许插入删除的一端称栈顶Top <3> 固定的一端称栈底Button <4> 先进后出 应用场景 <1> 子程序的调用 <2> 递归调用 <3> 表达式的转换与求值：前 后 中缀表达式 <4> 二叉树的遍历 <5> 图的深度优先搜素 数组模拟栈 public class ArrayStack { pub
数据结构--栈
YZG ' BLOG
12-22 954
一、栈的概念 1、栈是一个先入后出的有序结构 2、栈是限制性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 3、允许插入和删除的一段称为变化端，叫栈顶（Top），另一端叫栈底（Bottom），在栈的最低端。 4、压入元素在栈的最下端，称为压栈（Push），弹出元素从栈顶开始，称为弹栈（Pop） 压栈弹栈图解： 二、使用数组模拟栈【队列也是可以用数组模拟】 1、思路： ...
Java数据结构与算法——栈
★★光亭★★
03-13 9107
Java数据结构与算法——栈
[栈 字符串] 224. 基本计算器（栈的应用：符号栈+数字栈+出入栈规则、字符串解析） 227.基本计算器 II（出入栈规则、字符串解析）
m0_38142029的博客
09-30 576
[栈 字符串] 224. 基本计算器（栈的应用：符号栈+数字栈+出入栈规则、字符串解析）224. 基本计算器思路：栈 + 字符串解析实现遇到的问题：数字截取问题 224. 基本计算器 题目链接：https://leetcode-cn.com/problems/basic-calculator/ 分类： 栈（开辟符号栈、数字栈，设计出入栈规则，实现带括号的加减法） 数学/字符串（分析+实现基本计算器的功能，实质上是对字符串的解析：对数字、括号字符、加减法号的提取） 思路：栈 + 字符串解析 开辟两个
栈练习（数据结构第五周习题）
爱和九九的博客
09-28 962
在一个数组中实现两个堆栈 6-1 在一个数组中实现两个堆栈 (29 分) 本题要求在一个数组中实现两个堆栈。 函数接口定义： Stack CreateStack( int MaxSize ); bool Push( Stack S, ElementType X, int Tag ); ElementType Pop( Stack S, int Tag ); 其中Tag是堆栈编号，取1或2；Max...
leetcode--227 基本计算器II 数据栈 符号栈
ai-july
04-19 290
实现一个基本的计算器来计算一个简单的字符串表达式的值。 字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格。 整数除法仅保留整数部分。 示例1: 输入: "3+2*2" 输出: 7 示例 2: 输入: " 3/2 " 输出: 1 示例 3: 输入: " 3+5 / 2 " 输出: 5 说明： 你可以假设所给定的表达式都是有效的。 请不要使用内置的库...
栈的底层（数组）实现和栈实现的综合计算器
kaylee_study的博客
07-07 283
//使用栈完成计算一个表达式的结果 10*9-3+5 计算思路： 有两个栈 一个存放数字 一个存放运算符 1、将表达式字符串转换成字符数组 遍历字符数组 2、如果是数字 直接存放到数字栈 3、如果是符号 ；分为两种情况 （1） 如果符号栈没有为空 直接将符号入栈 （2）如果符号栈不为空 a、当运算符和栈内的运算符进行比较 如果当前的运算符的优先级低于或者等于栈中的运算符，就需要从数栈中...
数据结构——栈(stack)
qq_64191695的博客
07-06 966
栈(stack) 1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2.处理参数递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。 3.表达式的转换【中缀表达式转后缀表达式】和求值。 4.二叉树的遍历 5.图形的深度优先搜索法栈代码实现（数组）： 输出结果： 栈实现计算器： 中缀表达式的求值是平常最为熟悉的，但是对计算机说却不好操作（上述代码有些冗杂）。因此，在计算结束时，往往会将中缀表达
数据结构与算法：栈、队列和数组详解
本资源是一份关于数据结构与算法的PPT课件，专注于第四章的内容，主要讲解栈、队列和数组这三个核心主题。栈（Stack）是一种特殊的线性表，其特点是只允许在一端进行插入和删除操作，遵循“后进先出”（LIFO）原则。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值