代码随想录—力扣算法题：707设计链表.Java版（示例代码与导图详解）

版本说明

当前版本号[20230818]。

版本修改说明
20230818初版

目录

文章目录

  • 版本说明
  • 目录
  • 707.设计链表
    • 思路
      • 获取链表第index个节点的数值
      • 在链表的最前面插入一个节点
      • 在链表的最后面插入一个节点
      • 在链表第index个节点前面插入一个节点
      • 删除链表的第index个节点
    • 单链表角度
    • 总结

707.设计链表

力扣题目链接
更多内容可点击此处跳转到代码随想录，看原版文件

题意：

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

image-20230817200854967

思路

如果对链表的基础知识还不太懂和对链表的虚拟头结点不清楚，，可以看这篇文章：关于链表，你该了解这些！

删除链表节点：

image-20230818144606050

添加链表节点：

image-20230818144636451

这道题目设计链表的五个接口：

  • 获取链表第index个节点的数值
  • 在链表的最前面插入一个节点
  • 在链表的最后面插入一个节点
  • 在链表第index个节点前面插入一个节点
  • 删除链表的第index个节点

可以说这五个接口，已经覆盖了链表的常见操作，是练习链表操作非常好的一道题目

我们也将从这五个接口中，讲解每一个接口的思路让大家对本题有更加清晰的认知。

获取链表第index个节点的数值

  1. 检查index是否有效，如果index小于0或大于等于链表长度，则返回-1。

  2. 从头结点开始，定义一个指针currentNode指向head节点（虚拟头结点的下一个节点）。

    【为什么要定义指针currentNode呢？ 答：因为我们操作完链表后，要返回头结点，如果直接操作头结点，那么返回头结点的时候头结点的值已经改了。】

  3. 通过循环遍历，将currentNode指针移动index次，直到达到目标位置。

  4. 循环过程中，每次将currentNode指针指向currentNode的下一个节点，即currentNode = currentNode.next。

  5. 循环结束后，currentNode指针指向第index个节点。

  6. 返回currentNode的值，即currentNode.val，作为结果。

image-20230818161709180

在链表的最前面插入一个节点

  1. 创建一个新的节点，将值设置为val。

  2. 将新节点的next指针指向当前的头节点，即新节点的next指向原来的第一个节点。

    image-20230818162005456

    注：此时我们新建了一个新的结点new node ，然后形成下图的趋势去插入结点

    image-20230818162403398

    ​ 那在指示下，我们就会发现head所代表的下一个区域无法表达出来，因为：原先的head区域我们是可以用 dymghead - > next 来表示了，但又因为我们已经用其表示new node 了，已经修改了 dymghead - > next 的值去了，就无法再表达 head 的区域了。

    image-20230818162727448

从上面的教训我们就知道，应该先表达new node 和 head 的关系，再表达 dymghead ， 才不会出现修改了值，无法表达的情况。

于是先 表达 new node - > next = dymghead - > next ， 再表达dymghead - > next= new node ，即可。

image-20230818163422254

3.将链表的头节点指向新节点，使新节点成为新的头节点。

在链表的最后面插入一个节点

  1. 创建一个新的节点，将值设置为val。
  2. 如果链表为空，即**链表的头节点为null，将链表的头节点指向新节点。**新节点成为链表的唯一节点。
  3. 如果链表不为空，找到链表的最后一个节点。从头节点开始遍历链表，通过next指针逐个访问节点，直到找到最后一个节点。
  4. 将最后一个节点的next指针指向新节点，将新节点插入到链表的最后一个位置。

image-20230818164252981

在链表第index个节点前面插入一个节点

  1. 创建一个新的节点，将值设置为val。
  2. 检查index的值是否为0，如果是0，则直接调用addAtHead(val)方法，在链表的头部插入节点。
  3. 如果index大于0，需要找到链表的第index-1个节点。
  4. 从头节点开始遍历链表，通过next指针逐个访问节点，直到找到第index-1个节点。
  5. 将新节点的next指针指向第index个节点。
  6. 将第index-1个节点的next指针指向新节点。

image-20230818165850534

删除链表的第index个节点

  1. 检查index是否有效，如果index小于0或大于等于链表长度，则直接返回，不进行删除操作。
  2. 如果index有效，分为两种情况处理删除操作：
    • 如果index为0，即要删除的是链表的第一个节点。将链表的头节点指向第二个节点，即头节点的next指针所指向的节点。
    • 如果index不为0，需要找到第index-1个节点。从头节点开始遍历链表，通过next指针逐个访问节点，直到找到第index-1个节点。
  3. 将第index-1个节点的next指针指向第index+1个节点，即跳过要删除的节点。

image-20230818170459646

链表操作的两种方式：

  1. 直接使用原来的链表来进行操作。
  2. 设置一个虚拟头结点在进行操作。

下面采用的设置一个虚拟头结点（这样更方便一些，大家看代码就会感受出来）。

单链表角度

这段代码实现了一个单链表数据结构，包括了链表的初始化、插入、删除和获取等操作。让我们逐步分析每个方法的作用：

  1. ListNode类：用来表示链表的节点，包含一个整数val表示节点的值，以及一个指向下一个节点的指针next。

    //单链表
class ListNode { // 定义链表节点类
    int val; // 节点值
    ListNode next; // 指向下一个节点的指针

    ListNode() {
    } // 默认构造函数

    ListNode(int val) { // 带参构造函数
        this.val = val;
    }
}

  2. MyLinkedList类：实际上就是单链表的实现，包含以下几个核心属性和方法：

    • size：保存链表中节点的个数。

    • head：虚拟头结点，作为链表的起始位置。

    • MyLinkedList()：构造函数，用来初始化链表。将size设置为0，并创建一个值为0的虚拟头结点。

          int size; // 链表元素个数
    //虚拟头结点
    ListNode head; // 虚拟头节点

    //初始化链表
    public MyLinkedList() {  // 构造函数
        size = 0;  // 初始化链表大小为0
        head = new ListNode(0);  // 创建一个值为0的虚拟头节点
    }

    • get(int index)：**获取第index个节点的值。**如果index越界，返回-1。从头结点开始遍历链表，找到第index+1个节点，并返回其值。

     //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {  // 获取链表中第index个节点的值
        //如果index非法，返回-1
        if (index < 0 || index >= size) {  // 如果index小于0或大于等于链表大小，则索引非法，返回-1
            return -1;
        }
        ListNode currentNode = head;  // 从头结点开始遍历链表
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {  // 遍历找到第index+1个节点（包括虚拟头节点）
            currentNode = currentNode.next;
        }
        return currentNode.val;  // 返回第index个节点的值
    }
    • addAtHead(int val)：在链表的最前面插入一个节点，等价于在第0个元素前添加。调用addAtIndex(0, val)方法实现。
    • addAtTail(int val)：在链表的最后插入一个节点，等价于在末尾元素后添加。调用addAtIndex(size, val)方法实现。
        //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {  // 在链表最前面插入一个节点
        addAtIndex(0, val);  // 调用addAtIndex方法，在第0个位置插入节点
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {  // 在链表最后插入一个节点
        addAtIndex(size, val);  // 调用addAtIndex方法，在末尾位置插入节点
    }
    • addAtIndex(int index, int val)：在第index个节点之前插入一个新节点，如果index等于链表的长度，则插入为尾结点；如果index大于链表的长度，不进行插入。首先进行边界判断，然后找到第index个节点的前驱节点，创建一个新的节点并将其插入到合适的位置。
     // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {  // 在第index个节点之前插入一个新节点
        if (index > size) {  // 如果index大于链表大小，不进行插入，直接返回
            return;
        }
        if (index < 0) {  // 如果index小于0，将index调整为0
            index = 0;
        }
        size++;  // 链表大小加1
        //找到要插入节点的前驱
        ListNode pred = head;  // 找到要插入节点的前驱节点，从头结点开始遍历链表
        for (int i = 0; i < index; i++) {  // 遍历找到第index个节点的前驱节点
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);  // 创建一个新的节点
        toAdd.next = pred.next;  // 将新节点的next指针指向前驱节点的next指针指向的节点
        pred.next = toAdd;  // 将前驱节点的next指针指向新节点，实现节点插入
    }
    • deleteAtIndex(int index)：删除第index个节点。如果index越界，不进行删除。首先进行边界判断，然后找到第index个节点的前驱节点，将其next指针指向下一个节点的next指针，实现节点的删除。
 //删除第index个节点
    public void deleteAtIndex(int index) {  // 删除第index个节点
        if (index < 0 || index >= size) {  // 如果index小于0或大于等于链表大小，不进行删除，直接返回
            return; 
        }
        size--;  // 链表大小减1
        if (index == 0) {  // 如果要删除的是头结点
            head = head.next;  // 将头结点指向下一个节点即可完成删除操作
            return;
        }
        ListNode pred = head;  // 找到要删除节点的前驱节点，从头结点开始遍历链表
        for (int i = 0; i < index; i++) {  // 遍历找到第index个节点的前驱节点
            pred = pred.next;
        }
        pred.next = pred.next.next;  // 将前驱节点的next指针指向要删除节点的下一个节点，实现节点的删除
    }

这段代码实现了基本的单链表操作，并提供了对链表进行插入、删除和获取操作的接口。可以用来构建和操作一个链表数据结构。

单链表示例代码：

//单链表
class ListNode { // 定义链表节点类
    int val; // 节点值
    ListNode next; // 指向下一个节点的指针

    ListNode() {
    } // 默认构造函数

    ListNode(int val) { // 带参构造函数
        this.val = val;
    }
}

class MyLinkedList { // 定义链表类
    //size存储链表元素的个数
    int size; // 链表元素个数
    //虚拟头结点
    ListNode head; // 虚拟头节点

    //初始化链表
    public MyLinkedList() {  // 构造函数
        size = 0;  // 初始化链表大小为0
        head = new ListNode(0);  // 创建一个值为0的虚拟头节点
    }

    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {  // 获取链表中第index个节点的值
        //如果index非法，返回-1
        if (index < 0 || index >= size) {  // 如果index小于0或大于等于链表大小，则索引非法，返回-1
            return -1;
        }
        ListNode currentNode = head;  // 从头结点开始遍历链表
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {  // 遍历找到第index+1个节点（包括虚拟头节点）
            currentNode = currentNode.next;
        }
        return currentNode.val;  // 返回第index个节点的值
    }

    //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {  // 在链表最前面插入一个节点
        addAtIndex(0, val);  // 调用addAtIndex方法，在第0个位置插入节点
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {  // 在链表最后插入一个节点
        addAtIndex(size, val);  // 调用addAtIndex方法，在末尾位置插入节点
    }

 // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {  // 在第index个节点之前插入一个新节点
        if (index > size) {  // 如果index大于链表大小，不进行插入，直接返回
            return;
        }
        if (index < 0) {  // 如果index小于0，将index调整为0
            index = 0;
        }
        size++;  // 链表大小加1
        //找到要插入节点的前驱
        ListNode pred = head;  // 找到要插入节点的前驱节点，从头结点开始遍历链表
        for (int i = 0; i < index; i++) {  // 遍历找到第index个节点的前驱节点
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);  // 创建一个新的节点
        toAdd.next = pred.next;  // 将新节点的next指针指向前驱节点的next指针指向的节点
        pred.next = toAdd;  // 将前驱节点的next指针指向新节点，实现节点插入
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {  // 删除第index个节点
        if (index < 0 || index >= size) {  // 如果index小于0或大于等于链表大小，不进行删除，直接返回
            return;
        }
        size--;  // 链表大小减1
        if (index == 0) {  // 如果要删除的是头结点
            head = head.next;  // 将头结点指向下一个节点即可完成删除操作
            return;
        }
        ListNode pred = head;  // 找到要删除节点的前驱节点，从头结点开始遍历链表
        for (int i = 0; i < index; i++) {  // 遍历找到第index个节点的前驱节点
            pred = pred.next;
        }
        pred.next = pred.next.next;  // 将前驱节点的next指针指向要删除节点的下一个节点，实现节点的删除
    }

总结

针对这个题目，可以使用一个单链表的数据结构来实现所需的功能。

首先，需要定义一个链表节点的类，节点包含一个值和一个指向下一个节点的指针。

接下来，可以在链表类中实现以下功能：

  1. get(index)：从头节点开始遍历链表，直到找到第 index 个节点，然后返回该节点的值。如果遍历过程中超出了链表的长度，则返回 -1。
  2. addAtHead(val)：创建一个新的节点，将新节点的指针指向原来的头节点，然后将头指针指向新节点。
  3. addAtTail(val)：从头节点开始遍历链表，直到找到最后一个节点，将新节点追加到最后一个节点的指针上。
  4. addAtIndex(index, val)：如果 index 小于等于 0，则调用 addAtHead(val) 方法；如果 index 等于链表的长度，则调用 addAtTail(val) 方法；如果 index 大于链表长度，则不进行任何操作；否则，从头节点开始遍历链表，找到第 index - 1 个节点，然后创建一个新节点，将新节点的指针指向原来第 index 个节点的指针，再将第 index - 1 个节点的指针指向新节点。
  5. deleteAtIndex(index)：如果 index 小于 0 或者大于等于链表的长度，则不进行任何操作；如果 index 等于 0，则将头指针指向第二个节点；否则，从头节点开始遍历链表，找到第 index - 1 个节点，将其指针指向第 index + 1 个节点。

以上就是分析解题思路的主要步骤。实际编写代码时，需要根据具体语言的特点进行实现，并考虑一些边界条件的处理。

单链表与双链表示例代码：

//双链表
class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    //记录链表中元素的数量
    int size;
    //记录链表的虚拟头结点和尾结点
    ListNode head,tail;
    
    public MyLinkedList() {
        //初始化操作
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
        //判断index是否有效
        if(index<0 || index>=size){
            return -1;
        }
        ListNode cur = this.head;
        //判断是哪一边遍历时间更短
        if(index >= size / 2){
            //tail开始
            cur = tail;
            for(int i=0; i< size-index; i++){
                cur = cur.prev;
            }
        }else{
            for(int i=0; i<= index; i++){
                cur = cur.next; 
            }
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        //等价于在第0个元素前添加
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        //等价于在最后一个元素(null)前添加
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        //index大于链表长度
        if(index>size){
            return;
        }
        //index小于0
        if(index<0){
            index = 0;
        }
        size++;
        //找到前驱
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        //新建结点
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index<0 || index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}
new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index<0 || index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

构建可远程访问的企业内部论坛

构建可远程访问的企业内部论坛

文章目录 前言1.cpolar、PHPStudy2.Discuz3.打开PHPStudy&#xff0c;安装网页论坛所需软件4.进行网页运行环境的构建5.运行Discuz网页程序6.使用cpolar建立穿透内网的数据隧道&#xff0c;发布到公网7.对云端保留的空白数据隧道进行配置8.Discuz论坛搭建完毕 前言 企业在发展…
阅读更多...
PK Nounique CASCADE DROP INDEX keep index

PK Nounique CASCADE DROP INDEX keep index

Explicit Control Over Indexes when Creating, Disabling, or Dropping PK/Unique Constraints (Doc ID 139666.1)​编辑To Bottom PURPOSEIn Oracle 9i, the DBA has an explicit control over how indexes are affectedwhile creating, disabling, or dropping Primary Ke…
阅读更多...
分类预测 | MATLAB实现GWO-BiGRU-Attention多输入分类预测

分类预测 | MATLAB实现GWO-BiGRU-Attention多输入分类预测

分类预测 | MATLAB实现GWO-BiGRU-Attention多输入分类预测 目录 分类预测 | MATLAB实现GWO-BiGRU-Attention多输入分类预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 1.GWO-BiGRU-Attention 数据分类预测程序 2.代码说明&#xff1a;基于灰狼优化算法&#xff08;GW…
阅读更多...
Redis——hash类型详解

Redis——hash类型详解

概述 Redis本身就是键值对结构&#xff0c;而Redis中的value可以是哈希类型&#xff0c;为了区分这两个键值对&#xff0c;Redis中的键值对是key-value&#xff0c;而value中的哈希键值对则是field-value&#xff0c;其中value必须是字符串 下面介绍一些Redis的hash类型的常用…
阅读更多...
归并排序 与 计数排序

归并排序 与 计数排序

目录 1.归并排序 1.1 递归实现归并排序&#xff1a; 1.2 非递归实现归并排序 1.3 归并排序的特性总结: 1.4 外部排序 2.计数排序 2.1 操作步骤: 2.2 计数排序的特性总结: 3. 7种常见比较排序比较 1.归并排序 基本思想: 归并排序(MERGE-SORT)是建立在归并操作上的一种…
阅读更多...
集简云本周新增/更新：新增3大功能，集成19款应用，更新5款应用，新增近290个动作

集简云本周新增/更新：新增3大功能，集成19款应用，更新5款应用，新增近290个动作

本周更新概要 功能更新 ◉ 新增功能&#xff1a;语聚AI开放API功能 ◉ 新增功能&#xff1a;数据表表格公开分享功能 ◉ 新增功能&#xff1a;浏览器页面操作页面内容读取(增强版本&#xff09; 应用新增 新增应用&#xff1a;赛捷CRM 新增应用&#xff1a;快跑者 新增应…
阅读更多...
Matplotlib数据可视化（六）

Matplotlib数据可视化（六）

目录 1.绘制概率图 2.绘制雷达图 3.绘制流向图 4.绘制极坐标图 5.绘制词云图 1.绘制概率图 from scipy.stats import norm fig,ax plt.subplots() plt.rcParams[font.family] [SimHei] np.random.seed() mu 100 sigma 15 x musigma*np.random.randn(437) num_bins …
阅读更多...
GRPC 学习记录

GRPC 学习记录

GRPC 安装 安装 grpcio、grpcio-tools、protobuf、 pip install grpcio -i https://pypi.tuna.tsinghua.edu.cn/simple pip install grpcio-tools -i https://pypi.tuna.tsinghua.edu.cn/simple pip install protobuf -i https://pypi.tuna.tsinghua.edu.cn/simple常用类型 p…
阅读更多...
ai之美：探索写真照片软件的创造力

ai之美：探索写真照片软件的创造力

小青&#xff1a;嘿&#xff0c;小华&#xff0c;你知道最近ai艺术写真非常流行吗&#xff1f; 小华&#xff1a;真的吗&#xff1f;我还不知道呢。告诉我更多细节吧&#xff01; 小青&#xff1a;好的&#xff0c;ai艺术写真是指使用人工智能技术将照片转化为艺术作品的过程…
阅读更多...
arcgis数据采集与拓扑检查

arcgis数据采集与拓扑检查

1、已准备好一张配准好的浙江省行政区划图&#xff0c;如下&#xff1a; 2、现在需要绘制湖州市县级行政区划。需要右击文件夹新建文件地理数据库&#xff0c;如下&#xff1a; 其余步骤均默认即可。 创建好县级要素数据集后&#xff0c;再新建要素类&#xff0c;命名为县。 为…
阅读更多...
Unity制作一个简单的登入注册页面

Unity制作一个简单的登入注册页面

1.创建Canvas组件 首先我们创建一个Canvas画布&#xff0c;我们再在Canvas画布底下创建一个空物体&#xff0c;取名为Resgister。把空物体的锚点设置为全屏撑开。 2.我们在Resgister空物体底下创建一个Image组件&#xff0c;改名为bg。我们也把它 的锚点设置为全屏撑开状态。接…
阅读更多...
【python实现向日葵控制软件功能】手机远程控制电脑

【python实现向日葵控制软件功能】手机远程控制电脑

大家好&#xff0c;我是csdn的博主&#xff1a;lqj_本人 这是我的个人博客主页&#xff1a; lqj_本人_python人工智能视觉&#xff08;opencv&#xff09;从入门到实战,前端,微信小程序-CSDN博客 最新的uniapp毕业设计专栏也放在下方了&#xff1a; https://blog.csdn.net/lbcy…
阅读更多...
【CUDA】学习记录（4）-线程束的执行

【CUDA】学习记录（4）-线程束的执行

线程模型 block&#xff1a;同一个block内共享内存&#xff0c;同一block中的thread可以彼此进行通信。 block&#xff1a;block-local synchronization。同一个块内的线程可以同步。 线程&#xff0c;可以根据blockIdx和threadIdx唯一的指定。 作者&#xff1a;不会code的程序…
阅读更多...
MongoDB:数据库初步应用

MongoDB:数据库初步应用

一.连接MongoDB 1.MongoDBCompass连接数据库 连接路径:mongodb://用户名:密码localhost:27017/ 2.创建数据库(集合) MongoDB中数据库被称为集合. MongoDBCompass连接后,点击红色框加号创建集合,点击蓝色框加号创建文档(数据表) 文档中的数据结构(相当于表中的列)设计不用管…
阅读更多...
Linux——KVM虚拟化

Linux——KVM虚拟化

目录标题 虚拟化技术虚拟化技术发展案例KVM简介KVM架构及原理KVM原理KVM虚拟化架构/三种模式虚拟化前、虚拟化后对比KVM盖中盖套娃实验 虚拟化技术 通过虚拟化技术将一台计算机虚拟为多台逻辑计算机&#xff0c;在一台计算机上同时运行多个逻辑计算机&#xff0c;同时每个逻辑…
阅读更多...
PHP自己的框架实现config配置层级存取（完善篇二）

PHP自己的框架实现config配置层级存取（完善篇二）

1、实现效果 config(include_once $coreConfig); //加载配置文件config() //获取所有配置 config(DB_HOST) 获取配置 2、按层级配置文件加载&#xff0c;存取配置项 config,function.php function config($varNULL,$valueNULL){static $configarray();if(is_array($var)){…
阅读更多...
驱动day5

驱动day5

思维导图 练习 实现设备文件和设备的绑定&#xff0c;编写LED驱动 head.h #ifndef __HEAD_H__ #define __HEAD_H__typedef struct {unsigned int MODER;unsigned int OTYPER;unsigned int OSPEEDR;unsigned int PUPDR;unsigned int IDR;unsigned int ORD; }gpio_t;#define G…
阅读更多...
“RFID与光伏板的完美融合：探索能源科技的新时代！“

“RFID与光伏板的完美融合：探索能源科技的新时代！“

随着科技的不断发展&#xff0c;人类创造出了许多令人惊叹的发明。其中&#xff0c;RFID&#xff08;Radio Frequency Identification&#xff09;技术的应用在各个领域日益广泛。最近的研究表明&#xff0c;将RFID技术应用于光伏板领域&#xff0c;不仅可以提高光伏板的效率&a…
阅读更多...
kafka集成篇

kafka集成篇

kafka的Java客户端 生产者 1.引入依赖 <dependency><groupId>org.apache.kafka</groupId><artifactId>kafka-clients</artifactId><version>2.6.3</version></dependency>2.生产者发送消息的基本实现 /*** 消息的发送⽅*/ …
阅读更多...
常见的Web安全漏洞有哪些，Web安全漏洞常用测试方法介绍

常见的Web安全漏洞有哪些，Web安全漏洞常用测试方法介绍

Web安全漏洞是指在Web应用程序中存在的可能被攻击者利用的漏洞&#xff0c;正确认识和了解这些漏洞对于Web应用程序的开发和测试至关重要。 一、常见的Web安全漏洞类型&#xff1a; 1、跨站脚本攻击(Cross-Site Scripting&#xff0c;XSS)&#xff1a;攻击者通过向Web页面注入…
阅读更多...
最新文章

Copyright @ 2022~2023