数据结构(Java)---队列

news2024/11/24 13:57:50

1.简介

       队列是一种操作受限的线性表，和栈类似，队列的限制主要是运行在表的一端进行插入操作，而在表的另一端进行删除的操作（栈的操作受限是只能在一端进行插入和删除）。队列中进行插入的一端称为队尾 ，删除的一端称为队首。
       队列的操作规则是先进先出，先入队的元素先出队，所以队列又被称为先进先出表。队列分为线性队，链队，循环队列和双端队列。

2.顺序队

2.1 简介

       顺序队，采用顺序存储方式的队列称为顺序队，就是在内存中分配一段连续的存储空间来存放元素，常用的方式就是采用数组来实现。

2.2 相关操作

在这里插入图片描述
       顺序队列的实现和出入队的方法可以是：先定义一个数组用来存储数据，定义一个front和一个rear变量来辅助元素的出入队。当元素入队时，rear指针（变量）移动，然后将元素放在数组rear位置下（数组名[rear]），当rear=maxsize（数组大小）-1时，队列满了。元素出队时，front指针移动，然后将数组front位置下的元素删掉，当front=rear时，队列为空。

2.3 代码实现

package Structures;

import java.util.Scanner;

public class ArrayQueue {
    public static void main(String[] args) {
        Queue queue = new Queue(5);
        String key;
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while (loop){
            System.out.println("show: 输出队列");
            System.out.println("exit: 退出");
            System.out.println("add: 入队");
            System.out.println("get: 出队");
            System.out.println("请选择相关操作");
            while (loop){
                key = scanner.next();
                switch (key){
                    case "show":
                        queue.list();
                        break;
                    case "exit":
                        scanner.close();
                        loop = false;
                        break;
                    case "add":
                        System.out.println("请输入值：");
                        int i = scanner.nextInt();
                        queue.addQueue(i);
                        break;
                    case "get":
                        try{
                            int pop = queue.getQueue();
                            System.out.print(pop);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                }
            }
        }
    }
}

class Queue {
    private int[] data;
    private int front;
    private int rear;
    private int maxSize;

    public Queue(int maxSize) {
        this.maxSize = maxSize;
        data = new int[maxSize];
        front = -1;
        rear = -1;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }

    //判断队列是否满
    public boolean isFull(){
        return rear == maxSize-1;
    }

    //入队
    public void addQueue(int n){
        if(isFull()){
            System.out.println("队列已满");
            return;
        }
        rear++;
        data[rear] = n;
    }

    /*出队（注意：这里并不是真正的出队，只是将front移动返回值而已，实际上值还存在数组中，虽然数组是一个对象，但JavaApi并没有相对应的增删改查方法，可以借助ArrayUtils工具来将数组转为集合来操作）*/
    public int getQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列已经空了");
        }
        front++;
        return data[front];
    }

    //遍历队列
    public void list(){
        if (isEmpty()){
            System.out.println("队列为空");
            return;
        }
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i]);
        }
    }
}

在这里插入图片描述

3.环形队列

3.1 简介

在这里插入图片描述
       在顺序队列中，由于是使用front和rear指针（变量）来辅助队列的进队和出队，在判断队列满时使用rear=maxsize（数组大小）-1，但这样子会出现**假溢出（尽管元素出队了，但随着front指针的移动，数组产生一些空位置）**的情况，导致数组不可复用的情况出现，而环形队列则可以解决这个问题。
       环形队列主要是在顺序队的基础上，将数组的前端和后端连起来，形成一个环形数组，然后遵从队列的先进先出原则，被称为环形队列。

3.2 相关操作

在这里插入图片描述
       在创建循环队列时，和顺序队列不同的是，在循环队列中，front和rear的初始值都为0，而判断队满和队空的条件也不同，元素入队和出队的指针变量移动也不同（取余）。

队列的创建： 在循环队列中，front和rear的指针变量都等于0，直接指向数组的第一个元素，在循环队列中，数组存储元素的个数大小实际上比数组最大值少一个，因为要留一个空位来作为标记，比如上图的front和rear同时指向的那一个位置就是用来作为标记的。

public XQueue(int maxSize){
    this.maxSize = maxSize;
    front = 0;
    rear = 0;
    arr = new int[maxSize];
}

判断队空队满： 如上图所示：当rear+1= =front时，这时候表示队满了，因为循环队列要留一个位置来作为标志位，而在循环队列中，判断队满的条件是（rear+1）%maxSize == front ，因为是循环队列，rear的值是可以一直增长的，但（rear+1）% maxSize的范围一直在maxSize之内，比如说maxSize为4，那么（rear+1）%maxSize*的值就是0~4，范围在数组大小限制之内。而循环队列的判空的条件则是rear==front。

//队列判空
public boolean isFull(){
    return (rear+1)%maxSize == front;
}
    
//队列是否满
public boolean isEmpty(){
    return rear == front;
}

入队： 循环队列的入队分为两部分，首先是赋值然后是rear移位，之所以和顺序队不同是因为rear赋值时循环队列已经指向了数组的第一个位置0了，而rear的移位也和顺序队的不同，顺序队中rear的移位主要是rear = (rear+1)%maxSize，这样子rear的值尽管会一直增加，但+1并%maxSize后，rear最后的值都会在数组最大长度范围之内，不会造成数组下标越界的问题。

//进队
public void add(int n) {
    if (isFull()) {
        System.out.println("队列满了");
        return;
    }
    arr[rear] = n;
    //rear后移（（rear+1）这里是会一直加的）
    rear = (rear + 1) % maxSize;
}

出队： 在循环队列中元素的出队上，首先是获取到队首的元素，然后front指针移位，这里的front指针移位不是front++的了，而是front = （front+1）%maxSize，front最终的取值范围就不会超过数组长度，这样子的话front指针就会重新指回数组里的位置，从而形成环形队列。

//出队
public int get(){
    if (isEmpty()){
        throw new RuntimeException("队列为空");
    }
    int i = arr[front];
    front = (front+1)%maxSize;
    return i;
}

遍历： 循环队列中遍历数组的话，可以从队列中有效元素开始遍历，也就是从front开始，然后结束条件则是front加上队列中有效元素的个数，循环队列中计算队列中有效元素个数的是(rear+maxSize-front)%maxSize 。

//遍历
public void list(){
    if (isEmpty()){
        System.out.println("队空");
    }
    for (int i = front; i <front+(rear+maxSize-front)%maxSize; i++) {
        System.out.println(arr[i%maxSize]);
    }
}

3.3 代码实现

package Structures;

import java.util.Scanner;

public class XHQueue {
    public static void main(String[] args) {
        XQueue queue = new XQueue(5);
        String key;
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while (loop){
            System.out.println("show: 输出队列");
            System.out.println("exit: 退出");
            System.out.println("add: 入队");
            System.out.println("get: 出队");
            System.out.println("请选择相关操作");
            while (loop){
                key = scanner.next();
                switch (key){
                    case "show":
                        queue.list();
                        break;
                    case "exit":
                        scanner.close();
                        loop = false;
                        break;
                    case "add":
                        System.out.println("请输入值：");
                        int i = scanner.nextInt();
                        queue.add(i);
                        break;
                    case "get":
                        try{
                            int pop = queue.get();
                            System.out.print(pop);
                        }catch (Exception e){
                            System.out.println(e.getMessage());
                        }
                        break;
                }
            }
        }
    }
}

class XQueue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public XQueue(int maxSize) {
        this.maxSize = maxSize;
        front = 0;
        rear = 0;
        arr = new int[maxSize];
    }

    //队列判空
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    //队列是否满
    public boolean isEmpty() {
        return rear == front;
    }

    //进队
    public void add(int n) {
        if (isFull()) {
            System.out.println("队列满了");
            return;
        }
        arr[rear] = n;
        //rear后移（（rear+1）这里是会一直加的）
        rear = (rear + 1) % maxSize;
    }

    //出队
    public int get(){
        if (isEmpty()){
            throw new RuntimeException("队列为空");
        }
        int i = arr[front];
        front = (front+1)%maxSize;
        return i;
    }

    //遍历
    public void list(){
        if (isEmpty()){
            System.out.println("队空");
        }
        for (int i = front; i <front+((rear+maxSize-front)%maxSize); i++) {
            System.out.println(arr[i%maxSize]);
        }
    }
}

在这里插入图片描述

4.链队

4.1 简介

       链队主要是使用链表来实现队列，在单链表中，我们可以指定结点的插入和删除方式来实现队列的先进先出规则，即使用尾插法插入结点（入队）和在头结点处删除结点（出队），从而实现链队。

4.2 相关操作

在这里插入图片描述
       如上所示，在实现链队的过程中，首先创建一个带有front和rear的头结点（也可以定义一个front首节点和一个rear尾结点，将链队理解为带有头结点和尾结点的单链表），当元素进队时，采用尾插法的方式插入结点，此时使用的辅助指针变量的是rear，因为rear主要是指向rear尾部的，当元素出队时，删除front指针变量指向的结点，就是front后面的那一个结点。

入队： 采用尾插法的方式插入数据结点，当队列为空时，将front和rear都指向新结点，当队列不为空时，直接使用尾结点rear来进行插入即可。

public void add(Node node) {
    if (isEmpty()) {
        rear = front = node;
        length++;
    } else {
        rear.next = node;
        rear = node;
        length++;
    }
}

出队： 链队中的出队分为两种情况，当只剩下一个元素时，出队后将front和rear置空，当队列中有超过两个元素时，只需将front指向下一个元素（就是队列中的第二个元素）即可。

public void pop() {
    if (!isEmpty()) {
        if (length == 1) {
            front = rear = new Node("", "");
            length--;
        } else {
            front = front.next;
            length--;
        }
    }
}

4.3 代码实现

package Structures;

import java.util.EmptyStackException;

public class LinkedQueue {
    public static void main(String[] args) {
        Node node01 = new Node("1", "1");
        Node node02 = new Node("2", "2");
        Node node03 = new Node("3", "3");

        LQueue lQueue = new LQueue();
        lQueue.add(node01);
        lQueue.add(node02);
        lQueue.add(node03);

        lQueue.list();
        lQueue.pop();
        lQueue.list();
        lQueue.pop();
        lQueue.list();
    }

}

//结点信息
class Node {
    public String id;
    public String name;
    public Node next;

    public Node(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                "}";
    }
}

class LQueue {
    //创建首节点和尾结点
    Node front = new Node("", "");
    Node rear = new Node("", "");
    int length = 0;

    public boolean isEmpty() {
        return length == 0;
    }

    public void add(Node node) {
        if (isEmpty()) {
            rear = front = node;
            length++;
        } else {
            rear.next = node;
            rear = node;
            length++;
        }
    }

    public void pop() {
        if (!isEmpty()) {
            if (length == 1) {
                front = rear = new Node("", "");
                length--;
            } else {
                front = front.next;
                length--;
            }
        }
    }

    //输出链表
    public void list() {
        Node temp = front;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.print(temp);
            temp = temp.next;
        }
        System.out.println();
    }
}

在这里插入图片描述

5.双端队列

5.1 简介

在这里插入图片描述
       双端队列是指两端都可以进行进队和出队操作的队列，和普通的队列不同，普通的队列只允许在队尾进队和队首出队，而双端队列则是允许可以在两端进行操作的队列。双端队列可以使用顺序队（循环队列）和链队来实现。
       在双端队列中，进队时前端进的元素排列在队列中后端进的元素的前面，就是说在前端进的元素排在前面，但队列中元素的出队排序上，无论是前端出的还是后端出的，先出的都排在后出的前面。

       双端队列可以看做是队列和栈的结合体，他既可以先进先出也可以后进先出。在双端队列中，可以将双端队列变成普通的队列也可以变成栈来使用，这些也被称为受限的双端队列。比如：前端进后端出就是队列，前端进前端出就是栈。可以根据自己的需求来确定双端队列最后的形式（先进先出还是后进先出）。

5.2 相关操作

       在双端队列的实现中，大部分都是使用循环队列来实现的，这样子可以解决数组假溢出的问题，同时循环队列中也有front和rear两个指针变量，对双端队列的操作可以比较容易实现。

       其实双端队列使用循环队列来实现的话，可以理解为：front和rear同时指向了一个标志位，将这个标志位当成一个站在中间的人，前端进队的话就往左加，后端进队的话就往右加。

前端进队： 在前端入队上，主要是将front指针往前移动，从图中可以看出，front指针的移动从0指向了3，front的取值主要是(front-1+maxSize)%maxSize,这样子就可以取到相对应的数组下标值。
在这里插入图片描述

//前端入队
public void addFront(int n) {
    if (isFull()) {
        System.out.println("队列已满");
        return;
    }
    //新元素插到原先元素的前面，先移动指针
    front = (front - 1 + maxSize) % maxSize;
    data[front] = n;
}

后端进队： 后端进队就和循环队列的进队方式类似了，将rear指针往前移动一位即可，即rear= (rear+1)%maxSize。注意要先赋值再移位，因为rear指针要指向的是该元素的下一个位置。
在这里插入图片描述

//后端进队
public void addRear(int n) {
    if (isFull()) {
        System.out.println("队列已满");
        return;
    }
    //rear一开始指向的是一个空位置，先赋值
    data[rear] = n;
    rear = (rear + 1) % maxSize;
}

前端出队： 将front指针向前移动一位即可（(front+1)%maxSize）,注意的是，即使指针变量移动了一位，当实际上在数组中存储的数据还是存在的，并没有删除，可以通过后面添加进来的元素进行覆盖。
在这里插入图片描述

//前端出队
public void popFront() {
    if (isEmpty()) {
        System.out.println("队空");
        return;
    }
    int datum = data[front];
    front = (front + 1) % maxSize;
    System.out.println("出队的元素为：" + datum);
}

后端出队： 将rear指针向后移动一位（rear-1+maxSize）%maxSize，之所以在括号里面加上maxSize，是因为rear-1有可能出现负数。
在这里插入图片描述

//后端出队
public void popRear() {
    if (isEmpty()) {
        System.out.println("队空");
        return;
    }
    rear = (rear - 1 + maxSize) % maxSize;
    int datum = data[rear];
    System.out.println("出队的元素为：" + datum);
}

5.3 代码实现

package Structures;

import java.util.Scanner;

public class DoubleQueue {
    public static void main(String[] args) {
        DQueue dQueue = new DQueue(5);
        String key;
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("show: 输出队列");
            System.out.println("exit: 退出");
            System.out.println("addFront: 前端入队");
            System.out.println("getFront: 前端出队");
            System.out.println("addRear: 后端入队");
            System.out.println("getRear: 后端出队");
            System.out.println("请选择相关操作");
            while (loop) {
                key = scanner.next();
                switch (key) {
                    case "show":
                        dQueue.list();
                        break;
                    case "exit":
                        scanner.close();
                        loop = false;
                        break;
                    case "addFront":
                        System.out.println("请输入值：");
                        int i = scanner.nextInt();
                        dQueue.addFront(i);
                        break;
                    case "addRear":
                        System.out.println("请输入值：");
                        int a = scanner.nextInt();
                        dQueue.addRear(a);
                        break;
                    case "getFront":
                        System.out.println("请输入值：");
                        dQueue.popFront();
                        break;
                    case "getRear":
                        System.out.println("请输入值：");
                        dQueue.popRear();
                        break;
                }
            }
        }
    }
}

class DQueue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] data;

    public DQueue(int maxSize) {
        this.maxSize = maxSize;
        front = rear = 0;
        data = new int[maxSize];
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return front == rear;
    }

    //判断队列是否满了
    public boolean isFull() {
        return front == (rear + 1) % maxSize;
    }

    //前端入队
    public void addFront(int n) {
        if (isFull()) {
            System.out.println("队列已满");
            return;
        }
        //新元素插到原先元素的前面，先移动指针
        front = (front - 1 + maxSize) % maxSize;
        data[front] = n;
    }

    //后端进队
    public void addRear(int n) {
        if (isFull()) {
            System.out.println("队列已满");
            return;
        }
        //rear一开始指向的是一个空位置，先赋值
        data[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    //前端出队
    public void popFront() {
        if (isEmpty()) {
            System.out.println("队空");
            return;
        }
        int datum = data[front];
        front = (front + 1) % maxSize;
        System.out.println("出队的元素为：" + datum);
    }

    //后端出队
    public void popRear() {
        if (isEmpty()) {
            System.out.println("队空");
            return;
        }
        rear = (rear - 1 + maxSize) % maxSize;
        int datum = data[rear];
        System.out.println("出队的元素为：" + datum);
    }

    //遍历队列
    public void list() {
        if (isEmpty()) {
            System.out.println("队空");
        }
        for (int i = front; i < front + ((rear + maxSize - front) % maxSize); i++) {
            System.out.println(data[i % maxSize]);
        }
    }
}

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

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

相关文章

【JavaWeb】Servlet基础

【JavaWeb】Servlet基础

文章目录1.Tomcat服务器安装注意事项2.编写WebApp3.BS系统角色和协议4.模拟Servlet4.1模拟sun公司4.2模拟Tomcat服务器4.3模拟WebApp开发者5.开发一个带有Servlet的WebApp5.1创建一个名为crm的项目5.2 在项目中创建一个名为WEB-INF的文件&#xff08;必须&#xff09;5.3在WEB-…
阅读更多...
JAVA开发（java类加载过程）

JAVA开发（java类加载过程）

1、java语言的平台无关性。 因为java语言可以跑在java虚拟机上&#xff0c;所以只要能装java虚拟机的地方就能跑java程序。java语言以后缀名 .java为文件扩展名。通过java编译器javac编译成字节码文件.class 。java字节码文件通过java虚拟机解析运行。所以java语言可以说是编译…
阅读更多...
解决windows安装wxPython安装失败、速度过慢及PyCharm上wx包爆红问题

解决windows安装wxPython安装失败、速度过慢及PyCharm上wx包爆红问题

网上关于wxPython安装失败&#xff0c;安装速度过慢&#xff0c;以及安装成功后PyCharm中import wx仍然爆红的文章有很多&#xff0c;也特别杂&#xff0c;解决起来特别困难&#xff0c;今天在这里对问题的处理进行一个整合&#xff0c;希望能帮助到大家。 安装wxPython这里运用…
阅读更多...
模拟微信聊天-课后程序(JAVA基础案例教程-黑马程序员编著-第八章-课后作业)

模拟微信聊天-课后程序(JAVA基础案例教程-黑马程序员编著-第八章-课后作业)

【案例9-1】 模拟微信聊天 【案例介绍】 1.案例描述 在如今&#xff0c;微信聊天已经人们生活中必不可少的重要组成部分&#xff0c;人们的交流很多都是通过微信来进行的。本案例要求&#xff1a;将多线程与UDP通信相关知识结合&#xff0c;模拟实现微信聊天小程序。通过监…
阅读更多...
华为OD机试题【翻转单词顺序】用 C++ 进行编码 （2023.Q1）

华为OD机试题【翻转单词顺序】用 C++ 进行编码 （2023.Q1）

最近更新的博客 华为od 2023 | 什么是华为od，od 薪资待遇，od机试题清单） 文章目录 最近更新的博客使用说明翻转单词顺序题目输入输出示例一输入输出示例二输入输出说明示例三输入输出说明示例四
阅读更多...
解决跑pytorch代码报错AttributeError: module ‘distutils‘ has no attribute ‘version‘

解决跑pytorch代码报错AttributeError: module ‘distutils‘ has no attribute ‘version‘

跑pytorch代码报错AttributeError: module ‘distutils’ has no attribute ‘version’ Traceback (most recent call last): File “D:/pycharm_envir/gaozhiyuan/Segmentation/pytorch_segmentation/deeplabv3-plus-pytorch-main/train.py”, line 16, in from utils.callb…
阅读更多...
【C++修炼之路】22.哈希

【C++修炼之路】22.哈希

每一个不曾起舞的日子都是对生命的辜负 哈希一.哈希概念及性质1.1 哈希概念1.2 哈希冲突1.3 哈希函数二.哈希冲突解决2.1 闭散列/开放定址法2.2 开散列/哈希桶三.开放定址法代码3.1 插入Insert3.2 查找Find3.3 删除Erase3.4 映射的改良&完整代码四.开散列代码4.1 插入Inser…
阅读更多...
Linux之init.d、rc.d文件夹说明

Linux之init.d、rc.d文件夹说明

备注&#xff1a;Ubuntu没有rc.d文件夹&#xff0c;原因看问题四 Linux的几个重要文件 rc.d&#xff0c;init.d文件夹的说明 今天在研究mysql的安装的时候&#xff0c;最后一步要创建一个软连接&#xff0c;使得mysql服务可以自启动&#xff0c;代码如下&#xff1a; ln -s…
阅读更多...
扒系统CR8记录

扒系统CR8记录

目录 终极改造目标 过程记录 参考 为了将一套在线安装的系统&#xff0c;在不了解其架构、各模块细节的基础上&#xff0c;进行扒弄清楚&#xff0c;作以下记录。 终极改造目标 最终的目标&#xff0c;就是只通过CreMedia8_20230207.tar.gz解压 install 就把业务包安装了&…
阅读更多...
CorelDRAW2023新功能有哪些?最新版cdr下载安装教程

CorelDRAW2023新功能有哪些?最新版cdr下载安装教程

使用 CorelDRAW2023&#xff0c;随时随都能进行设计创作。在 Windows或Mac上使用专为此平台设计的直观界面&#xff0c;以自己的风格尽情自由创作。同全球数百万信赖CorelDRAW Graphics Suite 的艺术家、设计者及小型企业主一样&#xff0c;大胆展现真我&#xff0c;创作出众的…
阅读更多...
IAP初探

IAP初探

IAP(In-Application Programming)在应用编程&#xff0c;浅显易懂&#xff0c;按照字面意思即是在程序不关闭情况下&#xff0c;对应用进行再次写入程序&#xff0c;对程序的写入需要传输数据&#xff0c;而传输数据的前提是通信&#xff0c; IAP对代码进行更新可以简要分为以…
阅读更多...
【ElasticSearch系列-01】初识以及安装elasticSearch

【ElasticSearch系列-01】初识以及安装elasticSearch

elasticSearch入门和安装一&#xff0c;elasticSearch入门1&#xff0c;什么是elasticSearch2&#xff0c;elasticSearch的底层优点2.1&#xff0c;全文检索2.2&#xff0c;倒排索引2.2.1&#xff0c;正排索引2.2.2&#xff0c;倒排索引2.2.3&#xff0c;倒排索引解决的问题2.2…
阅读更多...
Linux | 2. 用户管理

Linux | 2. 用户管理

如有错误&#xff0c;恳请指出。 1. 设置文件权限 权限设置如下&#xff1a; root表示文件所有者&#xff0c;stud1表示文件所属组。其他用户无法访问。更改指令是chown。 更改目录文件所属组&#xff1a;chown .lab lossfound/更改目录文件所有者&#xff1a;chown lab loss…
阅读更多...
mac安装 Termius

mac安装 Termius

1.下载安装包 链接: https://pan.baidu.com/s/1f5xmvYnVehCkMUD291SbsA?pwdy43k 提取码: y43k 2.打开系统偏好设置 -> 安全性与隐私 -> 通用&#xff0c;勾选“任何来源” 显示文件损坏的情况下执行下面操作 3.打开terminal终端 3.1 输入&#xff1a;sudo spctl --m…
阅读更多...
windows10使用wsl2安装docker

windows10使用wsl2安装docker

配环境很麻烦&#xff0c;想利用docker的镜像环境跑一下代码整个安装过程的原理是&#xff1a;windows使用docker&#xff0c;必须先安装一个linux虚拟机&#xff0c;才可运行docker&#xff0c;而采用wsl2安装虚拟机是目前最好的方法第一步 windows安装wsl2控制面板->程序-…
阅读更多...
数据结构-考研难点代码突破（C++实现树型查找 - B树插入与遍历，B+树基本概念）

数据结构-考研难点代码突破（C++实现树型查找 - B树插入与遍历，B+树基本概念）

数据结构&#xff08;C&#xff09;[B树&#xff08;B-树&#xff09;插入与中序遍历&#xff0c;效率分析]、B树、B*树、B树系列应用 文章目录1. B树B树的插入与删除流程2. B树&#xff08;MySQL&#xff09;3. B树与B树对比4. C实现B树插入&#xff0c;中序遍历1. B树 B树类…
阅读更多...
面试题（基础篇）

面试题（基础篇）

1、你是怎样理解OOP面向对象的面向对象是利于语言对现实事物进行抽象。面向对象具有以下特征&#xff1a;&#xff08;1&#xff09;继承&#xff1a;继承是从已有类得到继承信息创建新类的过程&#xff08;2&#xff09;封装&#xff1a;通常认为封装是把数据和操作数据的方法…
阅读更多...
vue中的$forceUpdate()、$set()

vue中的$forceUpdate()、$set()

$forceUpdate() 迫使vue实例重新&#xff08;rander&#xff09;渲染虚拟dom&#xff0c;注意并不是重新加载组件。 结合vue的生命周期&#xff0c;调用 $forceupdate 后只会触发beforeupdate和updated这两个钩子函数&#xff0c;不会触发其他的钩子函数。它仅仅影响实例本身和…
阅读更多...
作为一名Android车载工程师，需要具备哪些能力？

作为一名Android车载工程师，需要具备哪些能力？

安卓开发在近几年的就业环境大家肯定都听说过&#xff0c;许多Android开发程序员都找不到自己满意的工作&#xff0c;于是纷纷另谋出路… 如今&#xff0c;随着Android汽车开发的兴起&#xff0c;很多Android开发者想转行做Android车载开发。然而&#xff0c;Android车载开发不…
阅读更多...
深入理解border以及应用

深入理解border以及应用

深入border属性以及应用&#x1f44f;&#x1f44f; border这个属性在开发过程中很常用&#xff0c;常常用它来作为边界的。但是大家真的了解border吗&#xff1f;以及它的形状是什么样子的。 我们先来看这样一段代码&#xff1a;&#x1f44f; <!--* Author: syk 185901…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023