【数据结构(四)】栈（1）

已于 2024-03-26 11:13:35 修改
阅读量297 收藏
点赞数
分类专栏： Java数据结构 文章标签： 数据结构
于 2023-11-21 19:15:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44883789/article/details/134520536
版权

文章目录

1. 关于栈的一个实际应用

设计一个简单的计算器：
    输入一个表达式，点击计算得出结果。
如：计算式:[7 * 2 * 2 - 5 + 1 - 5 + 3 - 3] 点击计算【如下图】

在这里插入图片描述

请问:
    计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算, 而是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。–> 栈

2. 栈的介绍

  • 栈(stack)是一个先入后出(FILO-First In Last Out)的有序列表。
  • 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。（允许插入和删除的）一端为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
  • 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

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

在这里插入图片描述

3. 栈的应用场景

  1. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
  2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
  3. 表达式的转换[中缀表达式 转 后缀表达式]与求值(实际解决)。
  4. 二叉树的遍历。
  5. 图形的深度优先(depth 一 first)搜索法。

4. 栈的简单应用

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

4.1. 思路分析

思路分析：(使用数组来模拟栈)

在这里插入图片描述

①定义一个 top 来表示栈顶，初始化 为 -1
②入栈的操作，当有数据加入到栈时， top++; stack[top] = data;
③出栈的操作， int value = stack[top]; top--, return value

4.2. 代码实现

package stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        // 创建一个ArrayStack对象-->表示栈
        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 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("程序退出");
    }
}

// 定义一个ArrayStck 表示栈
class ArrayStack {
    private int maxSize;// 栈的大小
    private int[] stack;// 数组，数组模拟栈：数据放在该数组
    private int top = -1;// top表示栈顶，初始化-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;
    }

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

    // 出栈(pop),将栈顶的数据返回
    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]);
        }
    }

}

运行结果：

在这里插入图片描述

习题拓展：
将上面的程序改成使用链表来模拟栈。

5. 栈的进阶应用(实现综合计算器)

5.1. 栈实现一位数计算(中缀表达式)

使用栈来实现综合计算器

问题：
    请输入一个表达式，通过点击“点击计算”来输出计算结果
    计算的表达式为：7 * 2 * 2 - 5 + 1 - 5 + 3 - 3

5.1.1. 思路分析

假设：
计算表达式为：3 + 2 * 6 - 2

计算思路：

1.通过一个 index 值（索引），来遍历我们的表达式

2.如果我们发现是一个数字, 就直接入数栈

在这里插入图片描述

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

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

在这里插入图片描述

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

因为计算表达式为：3 + 2 * 6 - 2
栈中已经存放了3和+，下一步该想数栈中存放2，直接入栈

在这里插入图片描述

接下来，扫描到符号 *
当前的操作符 * 的优先级大于栈中的操作符 + ，直接入符号栈

在这里插入图片描述

接下来，扫描到数字6，直接入数栈

在这里插入图片描述

接下来，扫描到符号 -
当前的操作符 - 的优先级小于(或等于)栈中的操作符 * ，不能直接入符号栈
需要从数栈中pop出两个数（6 和 2）,在从符号栈中pop出一个符号（*），进行运算，将得到结果（12），入数栈

2 * 6 = 12

在这里插入图片描述

然后将当前的操作符（ - ）入符号栈。

在这里插入图片描述

接下来，扫描到数字2，直接入数栈

在这里插入图片描述

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

①12 - 2 = 10

在这里插入图片描述

②3 + 10 =13

在这里插入图片描述

5.最后在数栈只有一个数字，就是表达式的结果（即13）

5.1.2. 代码实现

package stack;

public class Calculator {
    public static void main(String[] args) {
        // 给出一个计算表达式
        String expression = "3+2*6-2";
        // String expression = "7+2*6-4";

        // 创建两个栈：数栈 和 符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        // 定义相关变量
        int index = 0;// 用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';// 将每次扫描得到的char保存到ch

        // 使用while循环的扫描expression
        while (true) {
            // 一次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断ch是什么，然后做相应的处理
            if (operStack.isOper(ch)) {// 如果是运算符
                // 判断当前的符号是否为空
                if (!operStack.isEmpty()) {
                    // 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数
                    // 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        // 把运算的结果入 数栈
                        numStack.push(res);
                        // 然后将当前的操作符入 符号栈
                        operStack.push(ch);
                    } else {
                        // 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    // 如果为空直接入 符号栈
                    operStack.push(ch);
                }

            } else {// 如果是数，直接入 数栈
                numStack.push(ch - 48);// ASCII码表对应数值要减去48
            }
            // 让index++，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }

        }
        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            // 如果符号栈为空，就得到了最后的计算结果，数栈中只有一个数字（即运算结果）
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            // 把运算的结果入 数栈
            numStack.push(res);
        }
        // 将数栈的最后的数。pop出，就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}

// 先创建一个栈
// 定义一个ArrayStck 表示栈
class ArrayStack2 {
    private int maxSize;// 栈的大小
    private int[] stack;// 数组，数组模拟栈：数据放在该数组
    private int top = -1;// top表示栈顶，初始化-1

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

    // 增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek() {
        return stack[top];
    }

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

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

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

    // 出栈(pop),将栈顶的数据返回
    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 oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;// 假定目前的表达式只有+，-，*，/
        }
    }

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

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

}

运行结果：

在这里插入图片描述

注意：
上述代码在计算多位数会出现问题（比如计算：30+2*6-2，会错误的计算成10）
因为在数据读取的时候，是一个字符一个字符的读取，这样就把30拆成了 3 和 0 ，因此计算出错。

5.2. 栈实现多位数计算(中缀表达式)

5.2.1. 解决思路

1.当处理多位数时，不能发现是一个数就立即入栈，因为它可能是多位数
2.在处理数时，需要向expression的表达式的index后再看一位，如果是多位数就进行扫描，如果是符号才入栈
3.因此我们需要定义一个变量 字符串，用于拼接

5.2.2. 代码实现：

package stack;

public class Calculator {
    public static void main(String[] args) {
        // 给出一个计算表达式
        String expression = "30+2*6-2";
        // String expression = "7+2*6-4";

        // 创建两个栈：数栈 和 符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

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

        // 使用while循环的扫描expression
        while (true) {
            // 一次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断ch是什么，然后做相应的处理
            if (operStack.isOper(ch)) {// 如果是运算符
                // 判断当前的符号是否为空
                if (!operStack.isEmpty()) {
                    // 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数
                    // 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        // 把运算的结果入 数栈
                        numStack.push(res);
                        // 然后将当前的操作符入 符号栈
                        operStack.push(ch);
                    } else {
                        // 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    // 如果为空直接入 符号栈
                    operStack.push(ch);
                }

            } else {// 如果是数，直接入 数栈
                // numStack.push(ch - 48);// ASCII码表对应数值要减去48
                //分析思路
                //1. 当处理多位数时，不能发现是一个数就立即入栈，因为它可能是多位数
                //2.在处理数时，需要向expression的表达式的index后再看一位，如果是多位数就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个变量 字符串，用于拼接

                //处理多位数
                keepNum += ch;

                //如果ch已经是expression的最后一位，就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {

                    // 判断下一个字符是不是数字，如果是数字就继续扫描，如果是运算符，则入栈
                    // 注意：这里是看后一位，不是index++
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        // 如果后一位是运算符，则入栈(keepNum可能是 一位数，也可能是 多位数)
                        numStack.push(Integer.parseInt(keepNum));
                        // 注意：一定要清空keepNum
                        keepNum = "";

                    }
                }
            }
            // 让index++，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }

        }
        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            // 如果符号栈为空，就得到了最后的计算结果，数栈中只有一个数字（即运算结果）
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            // 把运算的结果入 数栈
            numStack.push(res);
        }
        // 将数栈的最后的数。pop出，就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}

// 先创建一个栈
// 定义一个ArrayStck 表示栈
class ArrayStack2 {
    private int maxSize;// 栈的大小
    private int[] stack;// 数组，数组模拟栈：数据放在该数组
    private int top = -1;// top表示栈顶，初始化-1

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

    // 增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek() {
        return stack[top];
    }

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

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

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

    // 出栈(pop),将栈顶的数据返回
    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 oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;// 假定目前的表达式只有+，-，*，/
        }
    }

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

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

}

运行结果：

在这里插入图片描述

习题拓展：

对上述代码加入功能，能够实现含小括号表达式的运算。

Cpdr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之——栈
WenJieya的博客
03-27 6916
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
数据结构栈的实验报告.doc
12-16
数据结构栈的实验报告 本实验报告主要介绍了数据结构栈的实验报告，涵盖了栈的基本概念、栈的实现、栈的操作算法以及栈的应用等方面。 一、栈的基本概念 栈是一种基本的数据结构，它是一种后进先出的数据结构，即...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构——栈的应用
m0_57484470的博客
10-23 3193
本文采用C语言具体实现栈结构的经典应用样例：数制转换，括号匹配，行编辑程序，表达式求值问题。
【图解数据结构】栈全面总结
知心宝贝的博客
12-23 1万+
一、前言 掌握栈这种抽象数据类型的特点，在相应的实际问题中正确应用 掌握栈类型的两种实现方法 二、基本概念 定义：只允许在一端进行插入或删除的线性表 栈顶（top）：允许进行插入或删除的一端 栈底（bottom）:与栈顶相对应的一端 特点：先进后出 三、栈的表示和实现 1.顺序栈 定义：一组地址连续的存储单元依次存放自栈底到栈顶的数据元素 top :用来表示栈顶元素的位置 top==-1表示空栈 top==NULL表示栈不存在 top>stacksize....
数据结构之栈
chuxinchangcun的博客
08-24 9709
一.什么是栈 二.几道小题开胃 三.栈的代码实现 1.创建项目 2.创建栈结构 3.栈的初始化 4.入栈操作 5.出栈操作 6.返回栈顶元素 7.求栈元素个数 8.判断栈是否为空 9.栈的销毁 四.总结： 五.原码链接 ...
C语言数据结构篇——用栈实现四则运算
Demo不是emo的博客
03-31 2万+
超详细的用栈实现四则表达式思路和代码（含完整代码）
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1668
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
数据结构：栈实现简易计算器
又蠢又笨的懒羊羊程序猿的博客
08-07 6554
文章目录栈实现简易计算器思路代码实现栈结构运算方法测试 栈实现简易计算器 之前的博客已经介绍了栈数据结构，栈有着数据先进后出的特点，因此用于实现简易计算器时相当方便。本博文中将介绍如何用栈实现一个可以进行简单四则运算不含括号的简易计算器（中缀表达式） 思路 首先创建两个栈，一个用于存储数而另一个用于存储运算符号。 首先需要一个index索引来遍历表达式 遍历到数字时直接入数栈 遍历到运算符时需要分情况讨论 如果当前符号栈为空直接入栈 如果当前符号栈不为空需要分情况讨论 当前遍历到的运算符的运算优先级小
C/C++数据结构（四） —— 栈
Edison's 小宇宙
10-03 1万+
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。
【数据结构】栈的详解
wangduduniubi的博客
05-18 1861
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
四种数据结构的特点 数据结构的特性
07-05
下面我们将详细介绍四种常见的数据结构的特点和特性。 数组 数组是一种最基本的数据结构，具有以下特点： * 优点：插入快，如果知道下标，可以快速存取。 * 缺点：查找慢，删除慢，大小固定。 数组的优点在于...
数据结构课程设计文档1
08-08
1. 数据结构：栈 在该设计中，使用栈来存储数字和运算符。栈是一种后进先出（LIFO）的数据结构，非常适合解决这个问题。通过使用栈，可以实现对数字和运算符的存储和处理。 2. 算法思路 算法思路是通过键盘输入...
数据结构实验3栈的实现.doc
05-20
"数据结构实验3栈的实现" 数据结构是一门基础的计算机科学课程，栈是数据结构中的一种重要数据类型。本实验报告将详细介绍栈的实现，包括栈的表示、入栈、出栈等操作，以及多种括号匹配问题的解决方案。 一、栈的...
计算机软件基础：12第四章数据结构栈_队列
05-08
"计算机软件基础：12第四章数据结构栈_队列" 数据结构是计算机科学中的一种重要概念，它是指在计算机中组织和存储数据的方式。栈和队列是两种常见的数据结构，本章将详细介绍栈和队列的定义、操作、存储方式和应用...
数据结构——bitset（位图）模拟实现
mastershooter的博客
06-11 602
第一种：构造一个8位的位图，所有为初始化为0//00000000第二种：构造一个8位的位图，根据所给的值初始化位图前N位//01100100第三种：构造一个8位的位图，根据字符串中的0/1序列来初始化位图的前N位//00111001。
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1165
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
【排序算法】总结篇
SWsunlight的博客
06-08 939
排序对比
数据结构下的线性回归模型
最新发布
qq_35320456的博客
06-11 602
线性回归是一种强大的统计工具，它可以帮助我们理解和预测数据之间的关系。通过使用适当的数据结构，我们可以有效地构建和训练线性回归模型，从而对新的输入进行准确的预测。在实际应用中，我们需要根据问题的具体情况进行适当的模型调整和优化，以获得最佳的结果。在本文中，我们介绍了线性回归模型的基本概念、原理以及如何在C#中实现一个简单的线性回归模型。通过示例代码，我们展示了如何使用数据结构来存储和处理数据，以及如何训练模型并进行预测。希望这篇博客能够帮助你更好地理解线性回归模型及其在实际中的应用。
迷宫问题java数据结构栈与队列
12-29
迷宫问题是一个经典的算法问题，可以使用Java中的数据结构栈和队列来解决。下面是一个使用栈和队列解决迷宫问题的示例代码： ```java import java.util.*; public class MazeSolver { private static final int[]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cpdr

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

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

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

打赏作者

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

抵扣说明：

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

余额充值