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

news2024/11/15 18:00:53

文章目录

  • 1. 关于栈的一个实际应用
  • 2. 栈的介绍
  • 3. 栈的应用场景
  • 4. 栈的简单应用
    • 4.1. 思路分析
    • 4.2. 代码实现
  • 5. 栈的进阶应用(实现综合计算器)
    • 5.1. 栈实现一位数计算(中缀表达式)
      • 5.1.1. 思路分析
      • 5.1.2. 代码实现
    • 5.2. 栈实现多位数计算(中缀表达式)
      • 5.2.1. 解决思路
      • 5.2.2. 代码实现：

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;
    }

}

运行结果：

在这里插入图片描述

习题拓展：

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1235995.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Java程序员面试专栏 专业技能篇】Java SE核心面试指引（二）：面向对象思想

【Java程序员面试专栏 专业技能篇】Java SE核心面试指引（二）：面向对象思想

关于Java SE部分的核心知识进行一网打尽，包括四部分：基础知识考察、面向对象思想、核心机制策略、Java新特性，通过一篇文章串联面试重点，并且帮助加强日常基础知识的理解，全局思维导图如下所示 本篇Blog为第二部分：面向对象思想，子节点表示追问或同级提问 面向对象基…
阅读更多...
《多GPU大模型训练与微调手册》

《多GPU大模型训练与微调手册》

全参数微调 Lora微调 PTuning微调 多GPU微调预备知识 1. 参数数据类型 torch.dtype 1.1 半精度 half-precision torch.float16&#xff1a;fp16 就是 float16&#xff0c;1个 sign&#xff08;符号位&#xff09;&#xff0c;5个 exponent bits(指数位)&#xff0c;10个 ma…
阅读更多...
[机缘参悟-119] ：一个IT人的反思：反者道之动；弱者，道之用 VS 恒者恒强，弱者恒弱的马太效应

[机缘参悟-119] ：一个IT人的反思：反者道之动；弱者，道之用 VS 恒者恒强，弱者恒弱的马太效应

目录 前言&#xff1a; 一、道家的核心思想 二、恒者恒强&#xff0c;弱者恒弱的马太效应 三、马太效应与道家思想的统一 3.1 大多数的理解 3.2 个人的理解 四、矛盾的对立统一 前言&#xff1a; 马太效应和强弱互转的道家思想&#xff0c;都反应了自然规律和社会规律&…
阅读更多...
【用unity实现100个游戏之16】Unity程序化生成随机2D地牢游戏3（附项目源码）

【用unity实现100个游戏之16】Unity程序化生成随机2D地牢游戏3（附项目源码）

文章目录 先本文看看最终效果前言二叉空间分割算法房间优先生成使用走廊连接各个房间BSP和随机游走源码完结 先本文看看最终效果 前言 前两期我们使用了随机游走算法已经实现了地牢的生成&#xff0c;本期再说另外一种生成地牢的方法&#xff0c;使用二叉空间分割算法&#xf…
阅读更多...
【Python数据结构与算法】--- 递归算法应用-五行代码速解汉诺塔问题.

【Python数据结构与算法】--- 递归算法应用-五行代码速解汉诺塔问题.

&#x1f308;个人主页: Aileen_0v0 &#x1f525;系列专栏:PYTHON数据结构与算法学习系列专栏&#x1f4ab;"没有罗马,那就自己创造罗马~" 汉诺塔 两层汉诺塔的演示 三层汉诺塔的走法演示 我不知道有没有朋友跟我一样有一个疑问,如果我们顶端的先放到中间柱子呢?…
阅读更多...
【算法】二分查找-20231122

【算法】二分查找-20231122

这里写目录标题 一、1089. 复写零二、917. 仅仅反转字母三、88. 合并两个有序数组四、283. 移动零 一、1089. 复写零 提示 简单 266 相关企业 给你一个长度固定的整数数组 arr &#xff0c;请你将该数组中出现的每个零都复写一遍&#xff0c;并将其余的元素向右平移。 注意&a…
阅读更多...
visionOS空间计算实战开发教程Day 2 使用RealityKit显示3D素材

visionOS空间计算实战开发教程Day 2 使用RealityKit显示3D素材

我们在​​Day1​​中学习了如何创建一个visionOS应用&#xff0c;但在第一个Demo应用中我们的界面内容还是2D的&#xff0c;看起来和其它应用并没有什么区别。接下来我们先学习如何展示3D素材&#xff0c;苹果为方便开发人员&#xff0c;推出了RealityKit&#xff0c;接下来看…
阅读更多...
Qml使用cpp文件的信号槽

Qml使用cpp文件的信号槽

文章目录 一、C文件Demo二、使用步骤1. 初始化C文件和QML文件&#xff0c;并建立信号槽2.在qml中调用 一、C文件Demo Q_INVOKABLE是一个Qt元对象系统中的宏&#xff0c;用于将C函数暴露给QML引擎。具体来说&#xff0c;它使得在QML代码中可以直接调用C类中被标记为Q_INVOKABLE的…
阅读更多...
ventoy安装操作系统

ventoy安装操作系统

下载ventoy https://github.com/ventoy/Ventoy/releases/download/v1.0.96/ventoy-1.0.96-windows.zip 解压后执行 Ventoy2Disk 2、安装后将ISO放入U盘大的分区&#xff0c;通过U盘启动就可以识别到ISO镜像开始装系统
阅读更多...
2021秋招-总目录

2021秋招-总目录

2021秋招-目录 知识点总结 预训练语言模型: Bert家族 1.1 BERT、attention、transformer理解部分 B站讲解–强烈推荐可视化推倒结合代码理解代码部分常见面试考点以及问题: word2vec 、 fasttext 、elmo;BN 、LN、CN、WNNLP中的loss与评价总结 4.1 loss_function&#xff1…
阅读更多...
AI大发展：人机交互、智能生活全解析

AI大发展：人机交互、智能生活全解析

目录 ​编辑 人工智能对我们的生活影响有多大 人工智能的应用领域 一、机器学习与深度学习 二、计算机视觉 三、自然语言处理 四、机器人技术 五、智能推荐系统 六、智能城市和智能家居 ​编辑 自己对人工智能的应用 自己的人工智能看法&#xff1a;以ChatGPT为例 …
阅读更多...
el-table 表格表头、单元格、滚动条样式修改

el-table 表格表头、单元格、滚动条样式修改

.2023.11.21今天我学习了如何对el-table表格样式进行修改&#xff0c;如图&#xff1a; 运用的两个样式主要是 1.header-cell-class-name&#xff08;设置表头&#xff09; 2.class-name&#xff08;设置行单元格&#xff09; 代码如下&#xff1a; <el-table :data&quo…
阅读更多...
人工智能基础_机器学习045_逻辑回归的梯度下降公式推导_更新公式---人工智能工作笔记0085

人工智能基础_机器学习045_逻辑回归的梯度下降公式推导_更新公式---人工智能工作笔记0085

然后我们上面有了逻辑回归的损失函数,以后,我们再来看 逻辑回归的梯度下降公式 可以看到上面是逻辑回归的梯度下降公式,这里的阿尔法是学习率,这里的 后面的部分是梯度也就是步长,这个阿尔法是,通过调节这个来控制梯度下降的快和慢对吧 然后我们再来看逻辑回归 可以看到这里…
阅读更多...
万字解析设计模式之 适配器模式

万字解析设计模式之 适配器模式

一、 适配器模式 1.1概述 将一个接口转换成客户希望的另一个接口&#xff0c;适配器模式使接口不兼容的那些类可以一起工作。 适配器模式分为类适配器模式和对象适配器模式&#xff0c;前者类之间的耦合度比后者高&#xff0c;且要求程序员了解现有组件库中的相关组件的内部结…
阅读更多...
【ArcGIS Pro二次开发】(77)：ArcGIS Pro中图层的获取与解析

【ArcGIS Pro二次开发】(77)：ArcGIS Pro中图层的获取与解析

一、最简单的获取图层方式 通常情况下&#xff0c;如果要获取当前地图中的图层&#xff0c;可以用2种方法获取。 以下图为例&#xff1a; 一种是【map.Layers】属性获取&#xff0c;结果如下&#xff1a; 可以看出&#xff0c;这里只获取到了第一层级的图层&#xff0c;图层组…
阅读更多...
创新无界：通义灵码在测试过程中展现的独特魅力

创新无界：通义灵码在测试过程中展现的独特魅力

通义灵码基于通义大模型&#xff0c;提供代码智能生成、研发智能问答能力。本文就来介绍下通义灵码在测试过程中的应用。 操作手册&#xff1a; 通义灵码, 阿里云提供的一款基于通义大模型的智能编码辅助工具_云效-阿里云帮助中心 1. 什么是通义灵码 是阿里云出品的一款基于通…
阅读更多...
数据结构与算法实验（黑龙江大学）

数据结构与算法实验（黑龙江大学）

实验一 顺序存储的线性表&#xff08;2 学时&#xff09; 一、实验目的 1 、掌握线性表的逻辑结构特征。 2、熟练掌握线性表的顺序存储结构的描述方法。 3 、熟练掌握顺序表上各种基本操作的实现。 二、实验内容 1 、设线性表的数据元素都为整数&#xff0c;存放在顺序表…
阅读更多...
C++使用Tensorflow2.6训练好的模型进行预测

C++使用Tensorflow2.6训练好的模型进行预测

要在C语言中调用训练好的TensorFlow模型，需要使用TensorFlow C API。 https://tensorflow.google.cn/install/lang_c?hl=zh-cnten TensorFlow 提供了一个 C API，该 API 可用于为其他语言构建绑定。该 API 在 c_api.h 中定义，旨在实现简洁性和一致性，而不是便利性。 下载…
阅读更多...
深度学习卫星遥感图像检测与识别 -opencv python 目标检测 计算机竞赛

深度学习卫星遥感图像检测与识别 -opencv python 目标检测 计算机竞赛

文章目录 0 前言1 课题背景2 实现效果3 Yolov5算法4 数据处理和训练5 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; **深度学习卫星遥感图像检测与识别 ** 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff0c;学长非常推荐…
阅读更多...
UE5的TimeLine的理解

UE5的TimeLine的理解

一直以来&#xff0c;我对动画的理解一直是这样的&#xff1a; 所谓动画&#xff0c;就是可导致可视化内容变化的参数和时间的对应关系。 我不能说这个观点现在过时了&#xff0c;只能说自己狭隘了。因为UE的TimeLine的设计理念真让人竖大拇指。 当我第一次看到TimeLine节点的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023