Java数据结构6-栈与队列

news2024/10/5 13:36:15

1. 栈(Stack)

1.1 概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则

  • 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶
  • 出栈：栈的删除操作叫做出栈。出数据在栈顶

在这里插入图片描述

栈在现实生活中的例子:

在这里插入图片描述

1.2 栈的使用


方法功能
Stack()构造一个空的栈
E push(E e)将 e 入栈，并返回 e
E pop()将栈顶元素出栈并返回
E peek()获取栈顶元素
int size()获取栈中有效元素个数
boolean empty()检测栈是否为空
public static void main(String[] args) {
  Stack<Integer> s = new Stack();
  s.push(1);
  s.push(2);
  s.push(3);
  s.push(4);
  System.out.println(s.size()); // 获取栈中有效元素个数---> 4
  System.out.println(s.peek()); // 获取栈顶元素---> 4
  s.pop(); // 4出栈，栈中剩余1 2 3，栈顶元素为3
  System.out.println(s.pop()); // 3出栈，栈中剩余1 2 栈顶元素为3
  if(s.empty()){
    System.out.println("栈空");
  }else{
    System.out.println(s.size());
  }
}

1.3 栈的模拟实现

在这里插入图片描述

从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。

import java.util.Arrays;

public class MyStack {

    public int[] elem;
    public int usedSize;

    public MyStack() {
        this.elem = new int[10];
    }

    public void push(int val) {
        if (isFull()) {
            elem = Arrays.copyOf(elem, 2*elem.length);
        }
        elem[usedSize] = val;
        usedSize++;
    }

    public boolean isFull() {
        return usedSize == elem.length;
    }

    public int pop() {
        if( empty() ){
            throw new RuntimeException("栈为空，无法删除元素");
        }
        int oldVal = elem[usedSize-1];
        usedSize--;
        return oldVal;
    }

    public boolean empty() {
        return usedSize == 0;
    }

    public int peek() {
        if(empty()){
            throw new RuntimeException("栈为空，无法获取栈顶元素");
        }

        return elem[usedSize-1];
    }


}

public class Test {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);

        System.out.println(myStack.pop());
        System.out.println(myStack.peek());
    }

}

1.4 栈的应用场景

  1. 改变元素的序列
1. 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A: 1,4,3,2 B: 2,3,4,1 C: 3,1,4,2 D: 3,4,2,1

C：输出3后不能跳过2就输出1

2.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺
序是（ ）。
A: 12345ABCDE B: EDCBA54321 C: ABCDE12345 D: 54321EDCBA

B
  1. 将递归转化为循环

比如：逆序打印链表

// 递归方式
void printList(Node head){
  if(null != head){
    printList(head.next);
    System.out.print(head.val + " ");
  }
}
// 循环方式
void printList(Node head){
  if(null == head){
    return;
  }
  Stack<Node> s = new Stack<>();
  // 将链表中的结点保存在栈中
  Node cur = head;
  while(null != cur){
    s.push(cur);
    cur = cur.next;
  }
// 将栈中的元素出栈
  while(!s.empty()){
    System.out.print(s.pop().val + " ");
  }
}
  1. 逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。

import java.util.Stack;

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> st = new Stack<>();
        for (String a:
             tokens) {
            if (a.equals("+")) {
                Integer num1 = st.pop();
                Integer num2 = st.pop();
                st.push(num2+num1);
            } else if (a.equals("-")) {
                Integer num1 = st.pop();
                Integer num2 = st.pop();
                st.push(num2-num1);
            } else if (a.equals("*")) {
                Integer num1 = st.pop();
                Integer num2 = st.pop();
                st.push(num2*num1);
            } else if (a.equals("/")) {
                Integer num1 = st.pop();
                Integer num2 = st.pop();
                st.push(num2/num1);
            } else {
                st.push(Integer.valueOf(a));
            }
        }
        return st.peek();
    }
}
  1. 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

import java.util.Stack;

class Solution {
    public boolean isValid(String s) {
        Stack<Character> sk = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(' || ch == '{' || ch == '[') {
                sk.push(ch);
            } else {
                if (sk.isEmpty()) {
                    return false;
                } else {
                    char chL = sk.peek();
                    if (chL == '(' && ch == ')' || chL == '{' && ch == '}'
                            ||chL == '[' && ch == ']') {
                         sk.pop();
                    } else {
                        return false;
                    }
                }
            }
        }
        return sk.empty();
    }
}
  1. 栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。

  1. 0<=pushV.length == popV.length <=1000
  2. -1000<=pushV[i]<=1000
  3. pushV 的所有数字均不相同
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pushV int整型一维数组 
     * @param popV int整型一维数组 
     * @return bool布尔型
     */
    
    public boolean IsPopOrder (int[] pushV, int[] popV) {
        // write code here
        int j = 0;
        Stack<Integer> sk = new Stack<>();
        for (int i = 0; i < pushV.length; i++) {
            sk.push(pushV[i]);
            while (j < popV.length && sk.peek() == popV[j]
                    && !sk.empty()) {
                sk.pop();
                j++;
            }
        }
        return sk.empty();
    }
}
  1. 最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

import java.util.Stack;

class MinStack {


    Stack<Integer> stack;
    Stack<Integer> minStack;
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if (minStack.empty()) {
            minStack.push(val);
        } else {
            Integer peekVal = minStack.peek();
            if (val <= peekVal) {
                minStack.push(val);
            }
        }
    }
    
    public void pop() {
        if (stack.empty()) {
            return;
        }
        Integer popVal = stack.pop();
        if (popVal.equals(minStack.peek())) {
            minStack.pop();
        }
        
    }
    
    public int top() {
        if (stack.empty()) {
            return -1;
        } 
        return stack.peek();
    }
    
    public int getMin() {
        if (minStack.empty()) {
            return -1;
        } 
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

2. 队列(Queue)

2.1 概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）

在这里插入图片描述

2.2 队列的使用

在Java中，Queue是个接口，底层是通过链表实现的。

在这里插入图片描述

方法功能
boolean offer(E e)入队列
E poll()出队列
E peek()获取队头元素
int size()获取队列中有效元素个数
boolean isEmpty()检测队列是否为空

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

public static void main(String[] args) {
  Queue<Integer> q = new LinkedList<>();
  q.offer(1);
  q.offer(2);
  q.offer(3);
  q.offer(4);
  q.offer(5); // 从队尾入队列
  System.out.println(q.size());
  System.out.println(q.peek()); // 获取队头元素
  q.poll();
  System.out.println(q.poll()); // 从队头出队列，并将删除的元素返回
  if(q.isEmpty()){
    System.out.println("队列空");
  }else{
    System.out.println(q.size());
  }
}

2.3 队列模拟实现

队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有两种：顺序结构 和 链式结构。

队列的实现使用顺序结构还是链式结构好？

public class MyQueue {

    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;
    public ListNode last;

    public void offer(int val) {
        ListNode node = new ListNode(val);
        if (head == null) {
            head = last = node;
        } else {
            last.next = node;
            node.prev = last;
            last = last.next;
        }
    }

    public int poll() {
        if (head == null) {
            return -1;
        }
        int ret = head.val;
        if (head.next == null) {
            head = null;
            last = null;
        } else {
           head = head.next;
           head.prev = null;
        }
        return ret;
    }

    public int peek() {
        if (head == null) {
            return -1;
        }
        return head.val;
    }

    public boolean isEmpty() {
        return head == null;
    }
}


public class Test {
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        myQueue.offer(1);
        myQueue.offer(2);
        myQueue.offer(3);

        System.out.println(myQueue.poll());
        System.out.println(myQueue.peek());
    }

}

2.4 循环队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现。

在这里插入图片描述

2.4.1 数组下标循环的小技巧

  1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length

在这里插入图片描述

  1. 下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length

在这里插入图片描述

2.4.2 如何区分空与满

  1. 通过添加 size 属性记录
  2. 保留一个位置
  3. 使用标记

2.4.3 设计循环队列

class MyCircularQueue {
    public int[] elem;
    public int first;
    public int last;

    public MyCircularQueue(int k) {
        elem = new int[k+1];
    }
    
    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }
        elem[last] = value;
        last = (last+1) % elem.length;
        return true;
    }
    
    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        first = (first+1) % elem.length;
        return true;
    }
    
    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return elem[first];
    }
    
    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        if (last == 0) {
            return elem[elem.length-1];
        } else {
            return elem[last-1];
        }
    }
    
    public boolean isEmpty() {
        return first == last;
    }
    
    public boolean isFull() {
        return (last+1) % elem.length == first;
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */

3. 双端队列 (Deque)

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

在这里插入图片描述

Deque是一个接口，使用时必须创建LinkedList的对象。

在这里插入图片描述

在实际工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口。

Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现

4. 面试题

1. 用队列实现栈

import java.util.LinkedList;
import java.util.Queue;

class MyStack {
    public Queue<Integer> queue1;
    public Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        if (empty()) {
            queue1.offer(x);
            return;
        }
        if (!queue1.isEmpty()) {
            queue1.offer(x);
        } else {
            queue2.offer(x);
        }
    }
    
    public int pop() {
        if (empty()) {
            return -1;
        }
        if (!queue1.isEmpty()) {
            int size = queue1.size();
            for (int i = 0; i < size-1; i++) {
                queue2.offer(queue1.poll());
            }
            return queue1.poll();
        } else {
            int size = queue2.size();
            for (int i = 0; i < size-1; i++) {
                queue1.offer(queue2.poll());
            }
            return queue2.poll();
        }
    }
    
    public int top() {
        if (empty()) {
            return -1;
        }
        if (!queue1.isEmpty()) {
            int ret = -1;
            int size = queue1.size();
            for (int i = 0; i < size; i++) {
                ret = queue1.poll();
                queue2.offer(ret);
            }
            return ret;

        } else {
            int ret = -1;
            int size = queue2.size();
            for (int i = 0; i < size; i++) {
                ret = queue2.poll();
                queue1.offer(ret);
            }
            return ret;
        } 
    }
    
    public boolean empty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}
/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

2. 用栈实现队列

import java.util.Stack;

class MyQueue {

    public Stack<Integer> stack1;
    public Stack<Integer> stack2;
    public MyQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }
    
    public void push(int x) {
        stack1.push(x);
    }
    
    public int pop() {
        if (empty()) {
            return -1;
        }
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();

    }
    
    public int peek() {
        if (empty()) {
            return -1;
        }
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }
    
    public boolean empty() {
        return stack1.empty() && stack2.empty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

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

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

相关文章

第11章 规划过程组（11.5创建WBS）

第11章 规划过程组（11.5创建WBS）

第11章 规划过程组&#xff08;一&#xff09;11.5创建WBS&#xff0c;在第三版教材第380~383页&#xff1b; 文字图片音频方式 视频22 第一个知识点&#xff1a;主要输入 1、项目管理计划 范围管理计划 定义了如何根据项目范围说明书创建WBS2、项目文件 项目范围说明…
阅读更多...
Uboot重定位

Uboot重定位

Uboot重定位 一、重定位的意义二、介绍一些重定位相关的表项结构（节）三、uboot的重定位过程：一、重定位的意义 uboot的重定位有两次，第一次是在编译成镜像后，在makefile中调用进行处理的，其调用tools/riscv_prelink.c的代码进行重定位处理（主要就是对重定位表中的R_RIS…
阅读更多...
为什么IP地址会被列入黑名单？

为什么IP地址会被列入黑名单？

您是否曾经历过网站访客数量骤减或电子邮件投递失败的困扰&#xff1f;这背后或许隐藏着一个常被忽略的原因&#xff1a;您的IP地址可能已经被列入了黑名单内。尽管您并没有进行任何违法的网络操作&#xff0c;但这个问题依然可能出现。那么&#xff0c;究竟黑名单是什么&#…
阅读更多...
巴黎成为欧洲AI中心 大学开始输出AI创始人

巴黎成为欧洲AI中心 大学开始输出AI创始人

来自Dealroom 的数据显示&#xff0c;在欧洲和以色列AI创业公司中&#xff0c;法国的AI创业公司资金最充裕。Mistral、Owkin、Hugging Face等法国企业已经融资23亿美元&#xff0c;比英国、德国AI创业公司都要多。 一名大学生走出校门凭借聪明才智和一个黄金点子成为富豪&#…
阅读更多...
36.基于多目标螳螂优化算法的微电网优化matlab

36.基于多目标螳螂优化算法的微电网优化matlab

微♥关注“电击小子程高兴的MATLAB小屋”获取资源 基于螳螂优化算法的多目标优化算法 求解微电网多目标优化调度 比较不同目标函数寻优对调度结果的影响 第1种.将两个目标函数值归一化相加&#xff0c;取相加后最小的目标值的粒子&#xff0c;即寻找折衷解并画图 第2种寻找…
阅读更多...
Matlab|【需求响应】空调负荷需求响应模型

Matlab|【需求响应】空调负荷需求响应模型

1主要内容 程序主要复现《溫控负荷的需求响应潜力评估及其协同优化管理研究_谢敦见》2.5部分章节的内容&#xff0c;建立空调负荷的聚合模型&#xff0c;考虑调节空调温度对空调响应潜力的影响&#xff0c;程序结果充分说明随着上调温度增大&#xff0c;响应程度逐渐增大。 具…
阅读更多...
CVE-2019-12272 Openwrt可视页面LuCi命令注入漏洞复现（更新中）

CVE-2019-12272 Openwrt可视页面LuCi命令注入漏洞复现（更新中）

漏洞简介 参考内容&#xff1a; CVE-2019-12272 OpenWrt图形化管理界面LuCI命令注入分析 | Math & Sec &#xff0c;HACHp1的个人博客 CVE-2019-12272 OpenWrt图形化管理界面LuCI命令注入分析_openwrt 图形界面-CSDN博客 exploits/CVE-2019-12272 at master oreosES/exp…
阅读更多...
PDF处理篇：如何调整 PDF 图像的大小

PDF处理篇：如何调整 PDF 图像的大小

将视觉效果无缝集成到 PDF 中的能力使它们成为强大的通信工具。然而&#xff0c;笨拙的图像大小会迅速扰乱文档的流程&#xff0c;阻碍清晰度和专业性。幸运的是&#xff0c;GeekerPDF 和Adobe Acrobat等流行的应用程序提供了用户友好的解决方案来应对这一挑战。这个全面的指南…
阅读更多...
螺旋矩阵问题C代码

螺旋矩阵问题C代码

给定一个n行m列的二维数组&#xff0c;要求按顺时针螺旋顺序输出矩阵中的所有元素&#xff0c;n和m小于等于10 如下图是一个三行四列的螺旋矩阵 要求输出 1 2 3 4 8 12 11 10 9 5 6 7 全局变量定义 int a[11][11]; int vis[11][11]; // 访问标记数组关键代码如下 int dx[] …
阅读更多...
原生APP开发的特点分析

原生APP开发的特点分析

原生APP开发是指使用官方提供的开发语言和工具&#xff0c;针对特定的移动平台进行应用程序开发。例如&#xff0c;Android平台的原生APP开发使用Java或Kotlin语言&#xff0c;iOS平台的原生APP开发使用Objective-C或Swift语言。北京木奇移动技术有限公司&#xff0c;专业的软件…
阅读更多...
使用Netty框架实现WebSocket服务端与客户端通信(附ssl)

使用Netty框架实现WebSocket服务端与客户端通信(附ssl)

仓库地址&#xff1a; https://gitee.com/lfw1024/netty-websocket 导入后可直接运行 预览页面 自签证书&#xff1a; #换成自己的本地ip keytool -genkey -alias server -keyalg RSA -validity 3650 -keystore D:\mystore.jks -ext sanip:192.168.3.7,ip:127.0.0.1,dns:lo…
阅读更多...
论文阅读_基本于文本嵌入的信息提取

论文阅读_基本于文本嵌入的信息提取

英文名&#xff1a;Embedding-based Retrieval with LLM for Effective Agriculture Information Extracting from Unstructured Data 中文名&#xff1a;基于嵌入的检索&#xff0c;LLM 从非结构化数据中提取有效的农业信息 地址: https://arxiv.org/abs/2308.03107 时间&…
阅读更多...
h5兼容table ，如何实现h5在app内使用h5渲染table表格而且实现横屏预览？

h5兼容table ，如何实现h5在app内使用h5渲染table表格而且实现横屏预览？

压图地址 横屏div 通过css 实现 transform: rotate(90deg); transformOrigin: 50vw 50vw ; height: 100vw; width: 100vh;<divclass"popup-box":style"{transform: originSet 0 ? rotate(90deg) : ,transformOrigin: originSet 0 ? 50vw 50vw : ,height…
阅读更多...
SARscape打开Sentinel1A SAR SLC产品（CSDB_20240630）

SARscape打开Sentinel1A SAR SLC产品（CSDB_20240630）

1.打开envi&#xff0c;在右侧工具包栏输入“sentinel-1”&#xff0c;并点击打开工具包。 2. 弹出文件导入界面&#xff0c;点击右侧Browse按钮。 3. 选在本地下载好的Sentinel1产品&#xff0c;文件路径最好全是英文&#xff0c;不要出现中文和特殊字符。 4 点击下方“Exec”…
阅读更多...
【PL理论深化】(12) Ocaml 语言：高阶函数 | map 函数 | filter 函数 | fold 函数

【PL理论深化】(12) Ocaml 语言：高阶函数 | map 函数 | filter 函数 | fold 函数

&#x1f4ac; 写在前面&#xff1a;在函数式编程中&#xff0c;除了递归函数外&#xff0c;还经常使用高阶函数。高阶函数是指接收其他函数作为参数或返回另一个函数的函数。高阶函数通过抽象编程模式以实现重用&#xff0c;使程序可以在更高层次上进行编写。让我们重点看看常…
阅读更多...
socket编程常见操作

socket编程常见操作

1、连接的建立 分为两种&#xff1a;服务端处理接收客户端的连接&#xff1b;服务端作为客户端连接第三方服务 //作为服务端 int listenfd socket(AF_INET, SOCK_STREAM, 0); bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) listen(listenfd, 10); //…
阅读更多...
JS（JavaScript）二级菜单级联案例演示

JS（JavaScript）二级菜单级联案例演示

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…
阅读更多...
Bazel plugin for Visual Studio Code

Bazel plugin for Visual Studio Code

语法突出显示 Bazel Build Targets 树显示工作区中的构建包/目标BUILD 文件中的 CodeLens 链接可通过单击目标直接启动构建或测试Buildifier 集成以检查和格式化您的 Bazel 文件&#xff08;需要安装 Buildifier&#xff09;tasks.json 的 Bazel Task 定义在构建期间调试 .bzl…
阅读更多...
排序【插入排序】

排序【插入排序】

排序的概念 排序&#xff1a;所谓排序&#xff0c;就是将一份数据&#xff0c;通过某个或者某些关键字的大小&#xff0c;进行递增或者递减排序的操作。 稳定性&#xff1a;假定在待排序的数据组中&#xff0c;存在多个相同的元素&#xff0c;若经过排序&#xff0c;这些数据…
阅读更多...
【论文阅读】transformer及其变体

【论文阅读】transformer及其变体

写在前面&#xff1a; transformer模型已经是老生常谈的一个东西&#xff0c;以transformer为基础出现了很多变体和文章&#xff0c;Informer、autoformer、itransformer等等都是顶刊顶会。一提到transformer自然就是注意力机制&#xff0c;变体更是数不胜数&#xff0c;一提到…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023