c# 数据结构 链表篇 有关双向链表的一切

news2025/4/16 9:00:19

        本人能力有限,如有不足还请斧正

目录

0.双向链表的好处

1.双向链表的分类

2.不带头节点的标准双向链表

节点类:有头有尾

链表类:也可以有头有尾 也可以只有头

增

头插

尾插

删

查

改

遍历

全部代码

3.循环双向链表

节点类

链表类

增

头插

尾插

删

查

遍历

全部代码

 

0.双向链表的好处

优势维度具体好处说明 / 示例对比单向链表的核心差异
双向遍历能力支持正向（next）和反向（prev）遍历，可灵活选择遍历方向- 可从任意节点出发，向前后两个方向遍历链表
- 例如：实现浏览器历史记录的 “前进 / 后退” 功能，直接通过 prev/next 指针操作		单向链表仅能单向遍历，反向操作需从头重新遍历
插入 / 删除效率已知当前节点时，插入 / 删除操作时间复杂度为 O (1)，无需提前获取前驱节点- 插入时，通过当前节点的 prev 指针直接找到前驱，更新前后节点的指针即可
- 删除时，直接通过 prev 和 next 指针连接前后节点，无需遍历查找前驱		单向链表删除 / 插入节点时，若无前驱节点引用，需 O (n) 时间遍历查找前驱
定位便利性可直接通过节点的 prev 指针反向定位前驱节点，无需额外存储或遍历- 在链表中间节点操作时，无需维护额外变量记录前驱
- 例如：实现双向队列（双端队列）的头尾插入 / 删除操作，可直接通过指针快速定位		单向链表需从头遍历才能找到前驱节点，定位效率低
边界操作简化处理头节点和尾节点的插入 / 删除时更简单，无需特殊处理头指针（若带头节点）- 带头节点的双向链表中，头节点和尾节点的操作与中间节点逻辑一致
- 例如：删除头节点时，直接通过头节点的 next 找到第一个数据节点，更新其 prev 为 null（非循环情况）		单向链表删除头节点需单独处理头指针，边界条件易出错
应用场景适配适合需要双向操作或频繁前后移动的场景- 操作系统进程调度队列（需快速调整进程优先级，前后移动节点）
- LRU 缓存淘汰算法（需快速删除最近最少使用节点并插入到头部）		单向链表无法高效支持反向操作，需额外数据结构辅助
数据一致性指针操作更安全，减少空指针异常风险（尤其在循环双向链表中）- 循环双向链表中，头节点 prev 指向尾节点，尾节点 next 指向头节点，避免首尾指针为 null 的情况
- 适合对稳定性要求高的场景（如内核数据结构）		单向链表尾节点 next 为 null，反向遍历时易触发空指针错误
算法灵活性支持更复杂的算法逻辑，如双向搜索、回退操作- 在双向链表中实现 “双指针搜索”（如从头尾同时向中间遍历）
- 支持撤销操作（如文本编辑器的撤销 / 重做，通过双向指针回退历史版本）		单向链表需额外栈结构记录历史节点，增加空间复杂度

1.双向链表的分类

分类标准类型核心特点示意图（简化）典型应用场景
是否带头节点带头节点双向链表- 头部有一个固定的头节点（不存储数据），头节点的next指向第一个数据节点
- 尾节点的prev指向头节点（非循环时头节点prev为null）		头节点(H) <-> 数据节点1 <-> 数据节点2 <-> ... <-> 尾节点(T)〔T.prev=H，H.next=数据节点1〕频繁进行插入 / 删除操作的场景（如链表初始化、边界操作更便捷）
(本文演示一)不带头节点双向链表- 直接以第一个数据节点作为头节点，头节点prev为null
- 尾节点next为null		数据节点1 <-> 数据节点2 <-> ... <-> 尾节点(T)〔T.next=null，数据节点1.prev=null〕内存资源敏感场景（节省头节点空间）
是否循环非循环双向链表- 头节点prev为null，尾节点next为null
- 链表头尾不相连		null <-> 头节点 <-> ... <-> 尾节点 <-> null单向遍历需求不高，但需双向操作的场景（如文件系统目录结构）
 循环双向链表- 头节点prev指向尾节点，尾节点next指向头节点
- 形成一个环形结构，可从任意节点出发遍历整个链表		头节点(H) <-> ... <-> 尾节点(T) <-> H循环数据处理（如循环缓冲区、操作系统进程调度队列）
节点结构扩展标准双向链表(和第一行重复)- 每个节点包含prev（前驱指针）和next（后继指针）
- 存储单一数据元素		节点: prev <-> data <-> next通用双向操作场景（如浏览器历史记录的前进 / 后退）
(本文不做演示)双向链表带附加属性- 节点额外包含其他属性（如优先级、时间戳等）
- 结构上仍保持双向指针		节点: prev <-> data <-> next <-> extra_attr复杂数据管理（如任务调度链表、带权重的链表）

2.不带头节点的标准双向链表

图解模型

每一个节点类Node 都有三个元素:前项 数据 后项

注意因为c#不用指针 所以所谓Prev和Next指向的都是节点类Node 

节点类:有头有尾

public class Node {
    public int data;
    public Node prev;
    public Node next;

    public Node(int data, Node prev = null, Node next=null) { 
        this.data = data;
        this.prev = prev;
        this.next = next;
    }
}

链表类:也可以有头有尾 也可以只有头

        这里你可能会有一些疑问 怎么又出现了一个HeadNode和一个TailNode呢?
        这是因为链表类需要这两个去抽象的节点以方便管理

public class DoublyLinkedList {

    public Node headNode;
    public Node tailNode;

    public DoublyLinkedList() {
        headNode = tailNode = null;
    }

增

头插

乾坤大挪移

    public void HeadAdd(int data) {
        //如果链表为空
        if (headNode == null) { 
           headNode = tailNode = new Node(data);
        }

        //双向链表的特殊性: 修改头节点时,需要把新节点的前项 后项 都挂上
        Node newNode = new Node(data, null, headNode);
        headNode.prev = newNode;

        //改变链表头
        headNode = newNode;

    }

尾插

    public void TailAdd(int data) {
        //如果尾巴为空 说明头也没有 所以下面判断头尾都可以
        if (headNode  == null)
        {   //if (tailNode ==null)
            headNode = tailNode = new Node(data);
        }

        //双向链表的特殊性: 修改尾节点时,需要把新节点的前项 后项 都挂上
        Node newNode = new Node(data, tailNode, null);
        tailNode.next = newNode;

        //改变链表尾
        tailNode =newNode ;
    }

删

无需遍历找前驱节点 找到Target直接调换其前后指针指向即可

 public void DeleteValue(int data)
 {
     if (headNode == null) return;

     Node current = headNode;
     while (current != null)
     {
         if (current.data == data)
         {
             //如果匹配到了则可能出现以下情况:
             //1 删除的是头节点
             if (current.prev == null)
                 headNode = current.next;
             //2.删除的是尾巴
             if (current.next == null)
                 tailNode = current.prev;
             //3.删除的是中间节点
             current.prev.next = current.next;
            
             current.next.prev = current.prev;

             return;
         }
         current = current.next;
     }
 }

查

查询找到的第一个目标

    public bool SearchValue(int data)
    {
        if (headNode == null) return true;

        Node current = headNode;
        while (current != null)
        {
            if (current.data == data)
            {
                Console.WriteLine("找到了目标"+data);
                return true;
            }
            current = current.next;
        }
        Console.WriteLine("没有目标" + data);
        return false;
    }

改

        关于改就是查的子集 只需要加一两行代码即可 所以不做演示

遍历

可以双向遍历链表哦

 #region 遍历打印
    /// <summary>
    /// 正向打印链表：按顺序输出链表中每个节点的数据
    /// </summary>
    public void PrintListForward()
    {
        // 从链表头节点开始遍历
        Node current = headNode;
        while (current != null)
        {
            // 输出当前节点的数据
            Console.Write(current.data + " ");
            // 移动到下一个节点
            current = current.next;
        }
        Console.WriteLine();
    }

    /// <summary>
    /// 反向打印链表：按逆序输出链表中每个节点的数据
    /// </summary>
    public void PrintListBackward()
    {
        // 从链表尾节点开始遍历
        Node current = tailNode;
        while (current != null)
        {
            // 输出当前节点的数据
            Console.Write(current.data + " ");
            // 移动到前一个节点
            current = current.prev;
        }
        Console.WriteLine();
    }

全部代码

using System;

public class Node
{
    public int data;
    public Node prev;
    public Node next;

    public Node(int data, Node prev = null, Node next = null)
    {
        this.data = data;
        this.prev = prev;
        this.next = next;
    }
}

public class DoublyLinkedList
{
    public Node headNode;
    public Node tailNode;

    public DoublyLinkedList()
    {
        headNode = tailNode = null;
    }

    #region 增
    /// <summary>
    /// 头插法
    /// </summary>
    public void HeadAdd(int data)
    {
        //如果链表为空
        if (headNode == null)
        {
            headNode = tailNode = new Node(data);
        }
        else
        {
            //双向链表的特殊性: 修改头节点时,需要把新节点的前项 后项 都挂上
            Node newNode = new Node(data, null, headNode);
            headNode.prev = newNode;
            //改变链表头
            headNode = newNode;
        }
    }

    public void TailAdd(int data)
    {
        //如果尾巴为空 说明头也没有 所以下面判断头尾都可以
        if (headNode == null)
        {
            //if (tailNode ==null)
            headNode = tailNode = new Node(data);
        }
        else
        {
            //双向链表的特殊性: 修改尾节点时,需要把新节点的前项 后项 都挂上
            Node newNode = new Node(data, tailNode, null);
            tailNode.next = newNode;
            //改变链表尾
            tailNode = newNode;
        }
    }
    #endregion

    #region 删
    public void DeleteValue(int data)
    {
        if (headNode == null) return;

        Node current = headNode;
        while (current != null)
        {
            if (current.data == data)
            {
                //如果匹配到了则可能出现以下情况:
                //1 删除的是头节点
                if (current.prev == null)
                {
                    headNode = current.next;
                    if (headNode != null)
                    {
                        headNode.prev = null;
                    }
                    else
                    {
                        tailNode = null;
                    }
                }
                //2.删除的是尾巴
                else if (current.next == null)
                {
                    tailNode = current.prev;
                    tailNode.next = null;
                }
                //3.删除的是中间节点
                else
                {
                    current.prev.next = current.next;
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next;
        }
    }
    #endregion

    #region 查询
    public bool SearchValue(int data)
    {
        if (headNode == null) return false;

        Node current = headNode;
        while (current != null)
        {
            if (current.data == data)
            {
                Console.WriteLine("找到了目标" + data);
                return true;
            }
            current = current.next;
        }
        Console.WriteLine("没有目标" + data);
        return false;
    }
    #endregion

    #region 遍历打印
    /// <summary>
    /// 正向打印链表：按顺序输出链表中每个节点的数据
    /// </summary>
    public void PrintListForward()
    {
        // 从链表头节点开始遍历
        Node current = headNode;
        while (current != null)
        {
            // 输出当前节点的数据
            Console.Write(current.data + " ");
            // 移动到下一个节点
            current = current.next;
        }
        Console.WriteLine();
    }

    /// <summary>
    /// 反向打印链表：按逆序输出链表中每个节点的数据
    /// </summary>
    public void PrintListBackward()
    {
        // 从链表尾节点开始遍历
        Node current = tailNode;
        while (current != null)
        {
            // 输出当前节点的数据
            Console.Write(current.data + " ");
            // 移动到前一个节点
            current = current.prev;
        }
        Console.WriteLine();
    }
    #endregion
}

3.循环双向链表

        循环链表就是将头节点的前项和尾节点的后项连到同一个节点

        简称:貂蝉在一起了 噗噗

  headNode.prev = newNode;
  tailNode.next = newNode;

节点类

并没有什么区别

public class Node
{
    public int data;
    public Node prev;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

链表类

也没有什么区别

public class DoublyCircularLinkedList
{
    public Node headNode;
    public Node tailNode;

    public DoublyCircularLinkedList()
    {
        headNode = tailNode = null;
    }

增

头插

只是将头节点的前项 和 尾节点的后项 连接在了一起

   /// <summary>
   /// 头插法
   /// </summary>
   public void HeadAdd(int data)
   {
       Node newNode = new Node(data);
       if (headNode == null)
       {
           headNode = tailNode = newNode;
           newNode.next = newNode;
           newNode.prev = newNode;
       }
       else
       {
           newNode.next = headNode;
           newNode.prev = tailNode;
           headNode.prev = newNode;
           tailNode.next = newNode;
           headNode = newNode;
       }
   }

尾插

    public void TailAdd(int data)
    {
        Node newNode = new Node(data);
        if (tailNode == null)
        {
            headNode = tailNode = newNode;
            newNode.next = newNode;
            newNode.prev = newNode;
        }
        else
        {
            newNode.next = headNode;
            newNode.prev = tailNode;
            tailNode.next = newNode;
            headNode.prev = newNode;
            tailNode = newNode;
        }
    }

删

    public void DeleteValue(int data)
    {
        if (headNode == null) return;

        Node current = headNode;
        do
        {
            if (current.data == data)
            {
                if (current.next == current)
                {
                    headNode = tailNode = null;
                }
                else
                {
                    if (current == headNode)
                    {
                        headNode = current.next;
                    }
                    if (current == tailNode)
                    {
                        tailNode = current.prev;
                    }
                    current.prev.next = current.next;
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next;
        } while (current != headNode);
    }

查

    public bool SearchValue(int data)
    {
        if (headNode == null) return false;

        Node current = headNode;
        do
        {
            if (current.data == data)
            {
                Console.WriteLine("找到了目标" + data);
                return true;
            }
            current = current.next;
        } while (current != headNode);
        Console.WriteLine("没有目标" + data);
        return false;
    }

遍历

    #region 遍历打印
    /// <summary>
    /// 打印链表：按顺序输出链表中每个节点的数据
    /// </summary>
    public void PrintList()
    {
        if (headNode == null) return;

        Node current = headNode;
        do
        {
            Console.Write(current.data + " ");
            current = current.next;
        } while (current != headNode);
        Console.WriteLine();
    }
    #endregion

全部代码

public class Node
{
    public int data;
    public Node prev;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

public class DoublyCircularLinkedList
{
    public Node headNode;
    public Node tailNode;

    public DoublyCircularLinkedList()
    {
        headNode = tailNode = null;
    }

    #region 增
    /// <summary>
    /// 头插法
    /// </summary>
    public void HeadAdd(int data)
    {
        Node newNode = new Node(data);
        if (headNode == null)
        {
            headNode = tailNode = newNode;
            newNode.next = newNode;
            newNode.prev = newNode;
        }
        else
        {
            newNode.next = headNode;
            newNode.prev = tailNode;
            headNode.prev = newNode;
            tailNode.next = newNode;
            headNode = newNode;
        }
    }

    public void TailAdd(int data)
    {
        Node newNode = new Node(data);
        if (tailNode == null)
        {
            headNode = tailNode = newNode;
            newNode.next = newNode;
            newNode.prev = newNode;
        }
        else
        {
            newNode.next = headNode;
            newNode.prev = tailNode;
            tailNode.next = newNode;
            headNode.prev = newNode;
            tailNode = newNode;
        }
    }
    #endregion

    #region 删
    public void DeleteValue(int data)
    {
        if (headNode == null) return;

        Node current = headNode;
        do
        {
            if (current.data == data)
            {
                if (current.next == current)
                {
                    headNode = tailNode = null;
                }
                else
                {
                    if (current == headNode)
                    {
                        headNode = current.next;
                    }
                    if (current == tailNode)
                    {
                        tailNode = current.prev;
                    }
                    current.prev.next = current.next;
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next;
        } while (current != headNode);
    }
    #endregion

    #region 查询
    public bool SearchValue(int data)
    {
        if (headNode == null) return false;

        Node current = headNode;
        do
        {
            if (current.data == data)
            {
                Console.WriteLine("找到了目标" + data);
                return true;
            }
            current = current.next;
        } while (current != headNode);
        Console.WriteLine("没有目标" + data);
        return false;
    }
    #endregion

    #region 遍历打印
    /// <summary>
    /// 打印链表：按顺序输出链表中每个节点的数据
    /// </summary>
    public void PrintList()
    {
        if (headNode == null) return;

        Node current = headNode;
        do
        {
            Console.Write(current.data + " ");
            current = current.next;
        } while (current != headNode);
        Console.WriteLine();
    }
    #endregion
}

 

 

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

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

相关文章

660 中值定理

660 中值定理

文章目录 前言168169170总结 前言 background music: 《代替》 张叶蕾 660 上面没有专门的中值定理章节&#xff0c;我蒙了。不过应该可以找一下。就是证明题&#xff0c;标志性应该还行。找一下。然后做一下。660 的题质量应该还是非常高的。但是积分中值定理&#xff0c;还有…
阅读更多...
Elasticsearch：AI 助理 - 从通才到专才

Elasticsearch：AI 助理 - 从通才到专才

作者&#xff1a;来自 Elastic Thorben Jndling 在 AI 世界中&#xff0c;关于构建针对特定领域定制的大型语言模型&#xff08;large language models - LLM&#xff09;的话题备受关注 —— 不论是为了更好的安全性、上下文理解、专业能力&#xff0c;还是更高的准确率。这个…
阅读更多...
数据结构——布隆过滤器

数据结构——布隆过滤器

目录 一、什么是布隆过滤器&#xff1f; 二、布隆过滤器的原理 三、布隆过滤器的特点 一、什么是布隆过滤器&#xff1f; 布隆过滤器是一种空间效率高、适合快速检索的数据结构&#xff0c;用于判断一个元素是否可能存在于一个集合中。它通过使用多个哈希函数和一个位数组来…
阅读更多...
机器学习常用算法总结

机器学习常用算法总结

1. 概述 机器学习的定义是对于某类任务T和性能度量P&#xff0c;如果一个计算机程序在T上其性能P随着经验E而自我完善&#xff0c;那么我们就称这个系统从经验E中学习&#xff0c;机器学习是人工智能的一种方法&#xff0c;它通过在大量数据中学习隐藏的规则&#xff0c;模式和…
阅读更多...
关于香橙派OrangePi 5 Ultra 这个开源板子，开发Android

关于香橙派OrangePi 5 Ultra 这个开源板子，开发Android

我下载了它资料中的开源Android13 系统SDK&#xff0c; 这个SDK连个git 都没有&#xff0c;把这种代码释放能称为开源吗&#xff1f;&#xff1f; 并且也就是说你买了这个板子&#xff0c;里面是没有任何关于RK3588的开发文档&#xff0c;如果你没玩过其他RK平台&#xff0c;估…
阅读更多...
ubuntu启动 Google Chrome 时默认使用中文界面，设置一个永久的启动方式

ubuntu启动 Google Chrome 时默认使用中文界面，设置一个永久的启动方式

方法 &#xff1a;通过桌面快捷方式设置 编辑 Chrome 的桌面快捷方式&#xff1a; 找到您的 Google Chrome 快捷方式文件。如果是通过菜单启动&#xff0c;通常会在以下路径找到与 Chrome 相关的 .desktop 文件&#xff1a; sudo vim /usr/share/applications/google-chrome.d…
阅读更多...
字节跳动开源 Godel-Rescheduler：适用于云原生系统的全局最优重调度框架

字节跳动开源 Godel-Rescheduler：适用于云原生系统的全局最优重调度框架

背景 在云原生调度中&#xff0c;一次调度往往无法解决所有问题&#xff0c;需要配合重调度来优化资源分配和任务摆放。传统的重调度框架主要集中在识别异常节点或任务&#xff0c;并通过迁移或删除来解决。然而&#xff0c;这些框架往往只能解决局部问题&#xff0c;无法提供…
阅读更多...
【大模型实战篇】--阿里云百炼搭建MCP Agent

【大模型实战篇】--阿里云百炼搭建MCP Agent

MCP协议&#xff08;Model Communication Protocol&#xff0c;模型通信协议&#xff09;是大语言模型&#xff08;LLM&#xff09;与外部系统或其他模型交互时的一种标准化通信框架&#xff0c;旨在提升交互效率、安全性和可扩展性。 目录 1.阿里云百炼--MCP 1.1.MCP 服务接…
阅读更多...
基于PySide6与pycatia的CATIA智能倒角工具开发全解析

基于PySide6与pycatia的CATIA智能倒角工具开发全解析

引言&#xff1a;工业设计中的倒角革命 在机械设计领域&#xff0c;倒角操作是零件加工前的必要工序。传统手动操作效率低下且易出错本文基于PySide6pycatia技术栈&#xff0c;提出一种支持批量智能倒角、参数动态校验、跨层级操作的自动化方案&#xff0c;其核心突破体现在&a…
阅读更多...
css 二维码始终显示在按钮的正下方，并且根据不同的屏幕分辨率自动调整位置

css 二维码始终显示在按钮的正下方，并且根据不同的屏幕分辨率自动调整位置

一、需求 “求职入口” 下面的浮窗位置在其正下方&#xff0c;并且浏览器分辨的改变&#xff08;拖动浏览器&#xff09;&#xff0c;位置依旧在最下方 二、实现 <div class"btn_box"><div class"btn_link id"js-apply">求职入口<di…
阅读更多...
串口接收的使用-中断

串口接收的使用-中断

1、引言 单片机串口、按键等等这种外部输入的&#xff0c; 用轮询的方式非常浪费资源&#xff0c;所以最好的方法就是使用中断接收数据。 2、串口 对于串口中断&#xff0c; 使用的非常频繁。 1. 基本原理 串口中断接收通过以下方式工作&#xff1a; 当串口接收到一个字节…
阅读更多...
处理 Flutter 没有反应

处理 Flutter 没有反应

现象 有以下几种 VS Code 中 Initializing the Flutter SDK. This may take a few minutes. 会一直维持在这个右下角提示窗, 但是无后续动作 Flutter CMD flutter_console.bat 执行 --version 或者 doctor [-v] 没有任何输出, 命令卡住 解决办法 参考官方说明 管理员身份…
阅读更多...
入门51单片机(1)-----点灯大师梦开始的地方

入门51单片机(1)-----点灯大师梦开始的地方

前言 这一次的博客主要是要记录一下学习的记录的,方便以后去复习一下的&#xff0c;当然这篇博客还是针于零基础的伙伴萌&#xff0c;看完这篇博客&#xff0c;大家就可以学会点灯了。 安装软件 方法一下一下来教&#xff01;&#xff01;萌新宝贝萌可以学会的&#xff01;帮…
阅读更多...
3.数组(随想录)

3.数组(随想录)

1.二分查找 *2.移除元素 还有一个小优化&#xff08;可以不看&#xff09; 3.有序数组的平方 *4.长度最小的子数组 &#xff08;3种解法&#xff09; 5.螺旋矩阵 ||
阅读更多...
C#设计模式-状态模式

C#设计模式-状态模式

状态模式案例解析&#xff1a;三态循环灯的实现 案例概述 本案例使用 状态模式&#xff08;State Pattern&#xff09; 实现了一个 三态循环灯 的功能。每点击一次按钮&#xff0c;灯的状态会按顺序切换&#xff08;状态1 → 状态2 → 状态3 → 状态1...&#xff09;&#xff…
阅读更多...
字节跳动开源 LangManus：不止是 Manus 平替，更是下一代 AI 自动化引擎

字节跳动开源 LangManus：不止是 Manus 平替，更是下一代 AI 自动化引擎

当 “AI 自动化” 成为科技领域最炙手可热的关键词&#xff0c;我们仿佛置身于一场激动人心的变革前夜。各行各业都在翘首以盼&#xff0c;期待 AI 技术能够真正解放生产力&#xff0c;将人类从繁琐重复的工作中解脱出来。在这个充满无限可能的时代&#xff0c;字节跳动悄然发布…
阅读更多...
21.C++11

21.C++11

1.列表初始化 1.1C11中的{} •C11以后想统⼀初始化⽅式&#xff0c;试图实现⼀切对象皆可⽤{}初始化&#xff0c;{}初始化也叫做列表初始化。 • 内置类型⽀持&#xff0c;⾃定义类型也⽀持&#xff0c;⾃定义类型本质是类型转换&#xff0c;中间会产⽣临时对象&#xff0c;最…
阅读更多...
STM32 HAL库之WDG示例代码

STM32 HAL库之WDG示例代码

独立看门狗&#xff08;IWDG&#xff09; 初始化独立看门狗&#xff0c;在main.c中的 MX_IWDG_Init();&#xff0c;也就是iwdg.c中的初始化代码 void MX_IWDG_Init(void) {/* USER CODE BEGIN IWDG_Init 0 *//* USER CODE END IWDG_Init 0 *//* USER CODE BEGIN IWDG_Init 1 …
阅读更多...
Spring AI 发布了它的 1.0.0 版本的第七个里程碑（M7）

Spring AI 发布了它的 1.0.0 版本的第七个里程碑（M7）

Spring AI 发布了它的 1.0.0 版本的第七个里程碑&#xff08;M7&#xff09;&#xff0c;下个月就是 RC1&#xff0c;紧接着就是 GA&#xff01;&#xff0c;对于我们 Java 开发者来说&#xff0c;这绝对是个值得关注的好消息&#xff01; 但是对于 Java 学习者来说&#xff0c…
阅读更多...
jdk 安装

jdk 安装

oracle官网 : Java Archive | Oracle 中国 export JAVA_HOME/Users/xxxxx/app/services/x86jdk/jdk1.8.0_431.jdk/Contents/Home export PATH$JAVA_HOME/bin:$PATH 华为镜像网站&#xff1a;Index of java-local/jdk
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023