C#进阶学习（五）单向链表和双向链表，循环链表（中）双向链表

news2025/5/19 5:00:06

     

目录

一、双向链表的声明

1. 节点类声明

 2. 链表类框架声明

3、实现其中的每一个函数 

增删操作（核心方法组）

删除操作（核心方法组）

查询操作（辅助方法）

维护方法（内部逻辑）

二、测试：

三、C#中的双向链表

复杂度对比表

  有了前面实现单链表的基础，那么今天的我们实现双向链表简直就是简简单单，请往下看。

一、双向链表的声明

1. 节点类声明

/// <summary>
/// 双向链表节点类（核心数据结构）
/// </summary>
/// <typeparam name="T">泛型数据类型</typeparam>
public class DoublyLinkedListNode<T>
{
    // 节点存储的实际数据
    public T Value { get; set; }

    // 前驱节点指针（关键特性）
    public DoublyLinkedListNode<T> Previous { get; set; }

    // 后继节点指针（关键特性）
    public DoublyLinkedListNode<T> Next { get; set; }

    /// <summary>
    /// 构造函数（初始化数据域）
    /// </summary>
    public DoublyLinkedListNode(T value)
    {
        Value = value;
        Previous = null;  // 初始化前驱指针
        Next = null;     // 初始化后继指针
    }
}

关键特性说明：

        双指针结构：同时维护Previous和Next指针，实现双向遍历

        泛型设计：支持任意数据类型存储

        独立节点：每个节点独立管理前后连接关系

 2. 链表类框架声明

/// <summary>
/// 双向链表容器类（核心操作实现）
/// </summary>
public class DoublyLinkedList<T>
{
    // 头尾指针（核心成员）
    private DoublyLinkedListNode<T> _head;
    private DoublyLinkedListNode<T> _tail;
    
    // 计数器（重要属性）
    public int Count { get; private set; }
    public bool IsEmpty => Count == 0;

    // 索引器（特色功能）
    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= Count)
                throw new IndexOutOfRangeException();
            
            var current = _head;
            for (int i = 0; i < index; i++)
                current = current.Next;
            
            return current.Value;
        }
    }

    // 增删操作（核心方法组）
    public void AddFirst(T value) { /* 实现略 */ }
    public void AddLast(T value) { /* 实现略 */ }
    public void InsertAt(int index, T value) { /* 实现略 */ }
    
    // 删除操作（核心方法组）
    public bool Remove(T value) { /* 实现略 */ }
    public void RemoveAt(int index) { /* 实现略 */ }
    public void RemoveFirst() { /* 实现略 */ }
    public void RemoveLast() { /* 实现略 */ }

    // 查询操作（辅助方法）
    public bool Contains(T value) { /* 实现略 */ }
    public int Find(T value) { /* 实现略 */ }

    // 维护方法（内部逻辑）
    private DoublyLinkedListNode<T> GetNodeAt(int index) { /* 实现略 */ }
    private void RemoveNode(DoublyLinkedListNode<T> node) { /* 实现略 */ }
}

3、实现其中的每一个函数 

增删操作（核心方法组）

（1）public void AddFirst(T value)

/// <summary>
/// 添加元素到链表头部
/// </summary>
/// <param name="value">要添加的数据</param>
public void AddFirst(T value)
{
    DoublyLinkedListNode<T> newNode = new DoublyLinkedListNode<T>(value);

    if (IsEmpty)
    {
        _head = _tail = newNode;
    }
    else
    {
        newNode.Next = _head;
        _head.Previous = newNode;
        _head = newNode;
    }
    Count++;
}

（2）public void AddLast(T value)

/// <summary>
/// 添加元素到链表尾部
/// </summary>
/// <param name="value">要添加的数据</param>
public void AddLast(T value)
{
    DoublyLinkedListNode<T> newNode = new DoublyLinkedListNode<T>(value);

    if (IsEmpty)
    {
        _head = _tail = newNode;
    }
    else
    {
        _tail.Next = newNode;
        newNode.Previous = _tail;
        _tail = newNode;
    }
    Count++;
}

（3）public void InsertAt(int index, T value)

/// <summary>
/// 在指定位置插入元素
/// </summary>
/// <param name="index">插入位置索引</param>
/// <param name="value">要插入的数据</param>
/// <exception cref="ArgumentOutOfRangeException">索引越界异常</exception>
public void InsertAt(int index, T value)
{
    if (index < 0 || index > Count)
        throw new ArgumentOutOfRangeException(nameof(index));

    if (index == 0)
    {
        AddFirst(value);
    }
    else if (index == Count)
    {
        AddLast(value);
    }
    else
    {
        DoublyLinkedListNode<T> newNode = new DoublyLinkedListNode<T>(value);
        DoublyLinkedListNode<T> current = GetNodeAt(index);

        newNode.Previous = current.Previous;
        newNode.Next = current;
        current.Previous.Next = newNode;
        current.Previous = newNode;

        Count++;
    }
}

删除操作（核心方法组）

（4）public bool Remove(T value)

/// <summary>
/// 删除第一个匹配的元素
/// </summary>
/// <param name="value">要删除的数据</param>
/// <returns>是否删除成功</returns>
public bool Remove(T value)
{
    DoublyLinkedListNode<T> current = _head;

    while (current != null)
    {
        if (EqualityComparer<T>.Default.Equals(current.Value, value))
        { 
    // 当T是int时：执行值比较（无需装箱）
    // 当T是string时：执行值内容比较
    // 当T是自定义类：优先使用IEquatable实现
    // 自动处理null值情况（current.Value或value为null时不会报错）
    //这里的if里面就相当于是一种更加安全的判断数据是否相等，不管是地址还是内容
            RemoveNode(current);
            return true;
        }
        current = current.Next;
    }
    return false;
}

这里的RemoveNode在下面哦 

（5）public void RemoveAt(int index)

/// <summary>
/// 删除指定位置的元素
/// </summary>
/// <param name="index">要删除的位置索引</param>
/// <exception cref="ArgumentOutOfRangeException">索引越界异常</exception>
public void RemoveAt(int index)
{
    if (index < 0 || index >= Count)
        throw new ArgumentOutOfRangeException(nameof(index));

    DoublyLinkedListNode<T> nodeToRemove = GetNodeAt(index);
    RemoveNode(nodeToRemove);
}

（6）public void RemoveFirst()

/// <summary>
/// 删除头节点
/// </summary>
/// <exception cref="InvalidOperationException">空链表异常</exception>
public void RemoveFirst()
{
    if (IsEmpty)
        throw new InvalidOperationException("链表为空");

    RemoveNode(_head);
}

（7）public void RemoveLast()

/// <summary>
/// 删除尾节点
/// </summary>
/// <exception cref="InvalidOperationException">空链表异常</exception>
public void RemoveLast()
{
    if (IsEmpty)
        throw new InvalidOperationException("链表为空");

    RemoveNode(_tail);
}

查询操作（辅助方法）

（8）public bool Contains(T value)

/// <summary>
/// 查找元素是否存在
/// </summary>
/// <param name="value">要查找的数据</param>
/// <returns>是否存在</returns>
public bool Contains(T value)
{
    return Find(value) != -1;
}

（9）public int Find(T value)

/// <summary>
/// 查找元素位置
/// </summary>
/// <param name="value">要查找的数据</param>
/// <returns>元素索引（未找到返回-1）</returns>
public int Find(T value)
{
    DoublyLinkedListNode<T> current = _head;
    int index = 0;

    while (current != null)
    {
        if (EqualityComparer<T>.Default.Equals(current.Value, value))
        {
            return index;
        }
        current = current.Next;
        index++;
    }
    return -1;
}

维护方法（内部逻辑）

（10） private DoublyLinkedListNode<T> GetNodeAt(int index)

// 私有辅助方法
private DoublyLinkedListNode<T> GetNodeAt(int index)
{
    if (index < 0 || index >= Count)
        throw new ArgumentOutOfRangeException(nameof(index));

    DoublyLinkedListNode<T> current = _head;
    for (int i = 0; i < index; i++)
    {
        current = current.Next;
    }
    return current;
}

（11） private void RemoveNode(DoublyLinkedListNode<T> node)

private void RemoveNode(DoublyLinkedListNode<T> nodeToRemove)
{
    if (nodeToRemove.Previous != null)
    {
        nodeToRemove.Previous.Next = nodeToRemove.Next;
    }
    else
    {
        _head = nodeToRemove.Next;
    }

    if (nodeToRemove.Next != null)
    {
        nodeToRemove.Next.Previous = nodeToRemove.Previous;
    }
    else
    {
        _tail = nodeToRemove.Previous;
    }

    Count--;
}

二、测试：

class Program
{
    static void Main(string[] args)
    {
        DoublyLinkedList<int> list = new DoublyLinkedList<int>();

        // 添加测试
        list.AddLast(1);
        list.AddFirst(0);
        list.InsertAt(2, 2);
        list.AddLast(3);

        Console.WriteLine("正向遍历：");
        list.PrintForward();  // 0 -> 1 -> 2 -> 3 -> null

        Console.WriteLine("\n反向遍历：");
        list.PrintBackward(); // 3 -> 2 -> 1 -> 0 -> null

        // 查找测试
        Console.WriteLine($"\n元素2的位置：{list.Find(2)}"); // 2
        Console.WriteLine($"是否存在元素5：{list.Contains(5)}"); // False

        // 修改测试
        list.Remove(2);
        list.RemoveAt(0);
        Console.WriteLine("\n删除元素2和头节点后的链表：");
        list.PrintForward(); // 1 -> 3 -> null

        // 清空测试
        list.Clear();
        Console.WriteLine($"\n清空后链表长度：{list.Count}"); // 0
    }
}

测试结果：

三、C#中的双向链表

        其实我们大可不必自己苦哈哈的实现双向链表，C#中已经给我们封装好了这样的一个类，下面一起来看看吧。

官方实现：System.Collections.Generic.LinkedList<T>

        1. 节点类：LinkedListNode<T>：

类名类型名称描述
LinkedListNode<T>属性List获取节点所属的LinkedList<T>对象
属性Value获取或设置节点存储的值
属性Next获取下一个节点（尾节点时返回null）
属性Previous获取上一个节点（头节点时返回null）
构造函数new(T value)创建独立节点（未关联到链表时使用）

        2. 链表类：LinkedList<T> 

类名类型名称描述
LinkedList<T>属性Count获取链表中实际包含的节点数量
属性First获取链表的第一个节点（头节点）
属性Last获取链表的最后一个节点（尾节点）
方法AddFirst(T value)在链表头部添加包含指定值的新节点
方法AddFirst(LinkedListNode<T>)将现有节点添加到链表头部
方法AddLast(T value)在链表尾部添加包含指定值的新节点
方法AddLast(LinkedListNode<T>)将现有节点添加到链表尾部
方法AddAfter(LinkedListNode<T>, T)在指定节点之后插入包含值的新节点
方法AddBefore(LinkedListNode<T>, T)在指定节点之前插入包含值的新节点
方法Remove(T value)删除第一个匹配值的节点（返回bool）
方法Remove(LinkedListNode<T>)删除指定节点（O(1)操作）
方法RemoveFirst()删除头节点
方法RemoveLast()删除尾节点
方法Find(T value)从头部开始查找第一个匹配值的节点（返回LinkedListNode<T>或null）
方法Contains(T value)判断链表是否包含指定值
方法Clear()清空所有节点

复杂度对比表

操作时间复杂度说明
AddFirst/AddLastO(1)头尾指针直接操作
AddAfter/AddBeforeO(1)已知节点时的指针修改
Remove(节点)O(1)直接修改相邻节点指针
Remove(值)O(n)需要遍历查找
FindO(n)最差情况需遍历整个链表
ContainsO(n)依赖Find实现

好的 那么双向链表的实现就到此了，接着我们回去看看循环链表。

附本文实现的双向链表：

using System;

/// <summary>
/// 双向链表节点类
/// </summary>
/// <typeparam name="T">节点数据类型</typeparam>
public class DoublyLinkedListNode<T>
{
    /// <summary>
    /// 节点数据值
    /// </summary>
    public T Value { get; set; }

    /// <summary>
    /// 前驱节点指针
    /// </summary>
    public DoublyLinkedListNode<T>? Previous { get; set; }

    /// <summary>
    /// 后继节点指针
    /// </summary>
    public DoublyLinkedListNode<T>? Next { get; set; }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="value">节点数据</param>
    public DoublyLinkedListNode(T value)
    {
        Value = value;
        Previous = null;
        Next = null;
    }
}

/// <summary>
/// 双向链表类
/// </summary>
/// <typeparam name="T">链表数据类型</typeparam>
public class DoublyLinkedList<T>
{
    /// <summary>
    /// 头节点
    /// </summary>
    private DoublyLinkedListNode<T>? _head;

    /// <summary>
    /// 尾节点
    /// </summary>
    private DoublyLinkedListNode<T>? _tail;

    /// <summary>
    /// 链表长度
    /// </summary>
    public int Count { get; private set; }

    /// <summary>
    /// 判断链表是否为空
    /// </summary>
    public bool IsEmpty => Count == 0;

    /// <summary>
    /// 索引器：通过索引访问元素
    /// </summary>
    /// <param name="index">元素位置</param>
    /// <returns>节点数据</returns>
    /// <exception cref="ArgumentOutOfRangeException">索引越界异常</exception>
    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= Count)
                throw new ArgumentOutOfRangeException(nameof(index));

            DoublyLinkedListNode<T>? current = _head;
            for (int i = 0; i < index; i++)
            {
                current = current.Next;
            }
            return current.Value;
        }
    }

    /// <summary>
    /// 添加元素到链表头部
    /// </summary>
    /// <param name="value">要添加的数据</param>
    public void AddFirst(T value)
    {
        DoublyLinkedListNode<T> newNode = new DoublyLinkedListNode<T>(value);

        if (IsEmpty)
        {
            _head = _tail = newNode;
        }
        else
        {
            newNode.Next = _head;
            _head.Previous = newNode;
            _head = newNode;
        }
        Count++;
    }

    /// <summary>
    /// 添加元素到链表尾部
    /// </summary>
    /// <param name="value">要添加的数据</param>
    public void AddLast(T value)
    {
        DoublyLinkedListNode<T> newNode = new DoublyLinkedListNode<T>(value);

        if (IsEmpty)
        {
            _head = _tail = newNode;
        }
        else
        {
            _tail.Next = newNode;
            newNode.Previous = _tail;
            _tail = newNode;
        }
        Count++;
    }

    /// <summary>
    /// 在指定位置插入元素
    /// </summary>
    /// <param name="index">插入位置索引</param>
    /// <param name="value">要插入的数据</param>
    /// <exception cref="ArgumentOutOfRangeException">索引越界异常</exception>
    public void InsertAt(int index, T value)
    {
        if (index < 0 || index > Count)
            throw new ArgumentOutOfRangeException(nameof(index));

        if (index == 0)
        {
            AddFirst(value);
        }
        else if (index == Count)
        {
            AddLast(value);
        }
        else
        {
            DoublyLinkedListNode<T> newNode = new DoublyLinkedListNode<T>(value);
            DoublyLinkedListNode<T> current = GetNodeAt(index);

            newNode.Previous = current.Previous;
            newNode.Next = current;
            current.Previous.Next = newNode;
            current.Previous = newNode;

            Count++;
        }
    }

    /// <summary>
    /// 删除第一个匹配的元素
    /// </summary>
    /// <param name="value">要删除的数据</param>
    /// <returns>是否删除成功</returns>
    public bool Remove(T value)
    {
        DoublyLinkedListNode<T> current = _head;

        while (current != null)
        {
            if (EqualityComparer<T>.Default.Equals(current.Value, value))
            {
                RemoveNode(current);
                return true;
            }
            current = current.Next;
        }
        return false;
    }

    /// <summary>
    /// 删除指定位置的元素
    /// </summary>
    /// <param name="index">要删除的位置索引</param>
    /// <exception cref="ArgumentOutOfRangeException">索引越界异常</exception>
    public void RemoveAt(int index)
    {
        if (index < 0 || index >= Count)
            throw new ArgumentOutOfRangeException(nameof(index));

        DoublyLinkedListNode<T> nodeToRemove = GetNodeAt(index);
        RemoveNode(nodeToRemove);
    }

    /// <summary>
    /// 删除头节点
    /// </summary>
    /// <exception cref="InvalidOperationException">空链表异常</exception>
    public void RemoveFirst()
    {
        if (IsEmpty)
            throw new InvalidOperationException("链表为空");

        RemoveNode(_head);
    }

    /// <summary>
    /// 删除尾节点
    /// </summary>
    /// <exception cref="InvalidOperationException">空链表异常</exception>
    public void RemoveLast()
    {
        if (IsEmpty)
            throw new InvalidOperationException("链表为空");

        RemoveNode(_tail);
    }

    /// <summary>
    /// 查找元素是否存在
    /// </summary>
    /// <param name="value">要查找的数据</param>
    /// <returns>是否存在</returns>
    public bool Contains(T value)
    {
        return Find(value) != -1;
    }

    /// <summary>
    /// 查找元素位置
    /// </summary>
    /// <param name="value">要查找的数据</param>
    /// <returns>元素索引（未找到返回-1）</returns>
    public int Find(T value)
    {
        DoublyLinkedListNode<T> current = _head;
        int index = 0;

        while (current != null)
        {
            if (EqualityComparer<T>.Default.Equals(current.Value, value))
            {
                return index;
            }
            current = current.Next;
            index++;
        }
        return -1;
    }

    /// <summary>
    /// 清空链表
    /// </summary>
    public void Clear()
    {
        _head = null;
        _tail = null;
        Count = 0;
    }

    /// <summary>
    /// 遍历打印链表（正向）
    /// </summary>
    public void PrintForward()
    {
        DoublyLinkedListNode<T> current = _head;
        while (current != null)
        {
            Console.Write($"{current.Value} -> ");
            current = current.Next;
        }
        Console.WriteLine("null");
    }

    /// <summary>
    /// 遍历打印链表（反向）
    /// </summary>
    public void PrintBackward()
    {
        DoublyLinkedListNode<T> current = _tail;
        while (current != null)
        {
            Console.Write($"{current.Value} -> ");
            current = current.Previous;
        }
        Console.WriteLine("null");
    }

    // 私有辅助方法
    private DoublyLinkedListNode<T> GetNodeAt(int index)
    {
        if (index < 0 || index >= Count)
            throw new ArgumentOutOfRangeException(nameof(index));

        DoublyLinkedListNode<T> current = _head;
        for (int i = 0; i < index; i++)
        {
            current = current.Next;
        }
        return current;
    }

    private void RemoveNode(DoublyLinkedListNode<T> nodeToRemove)
    {
        if (nodeToRemove.Previous != null)
        {
            nodeToRemove.Previous.Next = nodeToRemove.Next;
        }
        else
        {
            _head = nodeToRemove.Next;
        }

        if (nodeToRemove.Next != null)
        {
            nodeToRemove.Next.Previous = nodeToRemove.Previous;
        }
        else
        {
            _tail = nodeToRemove.Previous;
        }

        Count--;
    }
}

// 示例使用
class Program
{
    static void Main(string[] args)
    {
        DoublyLinkedList<int> list = new DoublyLinkedList<int>();

        // 添加测试
        list.AddLast(1);
        list.AddFirst(0);
        list.InsertAt(2, 2);
        list.AddLast(3);

        Console.WriteLine("正向遍历：");
        list.PrintForward();  // 0 -> 1 -> 2 -> 3 -> null

        Console.WriteLine("\n反向遍历：");
        list.PrintBackward(); // 3 -> 2 -> 1 -> 0 -> null

        // 查找测试
        Console.WriteLine($"\n元素2的位置：{list.Find(2)}"); // 2
        Console.WriteLine($"是否存在元素5：{list.Contains(5)}"); // False

        // 修改测试
        list.Remove(2);
        list.RemoveAt(0);
        Console.WriteLine("\n删除元素2和头节点后的链表：");
        list.PrintForward(); // 1 -> 3 -> null

        // 清空测试
        list.Clear();
        Console.WriteLine($"\n清空后链表长度：{list.Count}"); // 0
    }
}

 

 

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

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

相关文章

重学Redis：Redis常用数据类型+存储结构（源码篇）

重学Redis：Redis常用数据类型+存储结构（源码篇）

一、SDS 1&#xff0c;SDS源码解读 sds (Simple Dynamic String)&#xff0c;Simple的意思是简单&#xff0c;Dynamic即动态&#xff0c;意味着其具有动态增加空间的能力&#xff0c;扩容不需要使用者关心。String是字符串的意思。说白了就是用C语言自己封装了一个字符串类型&a…
阅读更多...
js原型和原型链

js原型和原型链

js原型&#xff1a; 1、原型诞生的目的是什么呢&#xff1f; js原型的产生是为了解决在js对象实例之间共享属性和方法&#xff0c;并把他们很好聚集在一起&#xff08;原型对象上&#xff09;。每个函数都会创建一个prototype属性&#xff0c;这个属性指向的就是原型对象。 …
阅读更多...
OpenHarmony - 小型系统内核（LiteOS-A）（五）

OpenHarmony - 小型系统内核（LiteOS-A）（五）

OpenHarmony - 小型系统内核&#xff08;LiteOS-A&#xff09;&#xff08;五&#xff09; 六、文件系统 虚拟文件系统 基本概念 VFS&#xff08;Virtual File System&#xff09;是文件系统的虚拟层&#xff0c;它不是一个实际的文件系统&#xff0c;而是一个异构文件系统之…
阅读更多...
PyTorch进阶学习笔记[长期更新]

PyTorch进阶学习笔记[长期更新]

第一章 PyTorch简介和安装 PyTorch是一个很强大的深度学习库&#xff0c;在学术中使用占比很大。 我这里是Mac系统的安装&#xff0c;相比起教程中的win/linux安装感觉还是简单不少&#xff08;之前就已经安好啦&#xff09;&#xff0c;有需要指导的小伙伴可以评论。 第二章…
阅读更多...
proteus8.17 环境配置

proteus8.17 环境配置

Proteus介绍 Proteus 8.17 是一款功能强大的电子设计自动化&#xff08;EDA&#xff09;软件&#xff0c;广泛应用于电子电路设计、仿真和分析。以下是其主要特点和新功能&#xff1a; ### 主要功能 - **电路仿真**&#xff1a;支持数字和模拟电路的仿真&#xff0c;包括静态…
阅读更多...
Java对接Dify API接口完整指南

Java对接Dify API接口完整指南

Java对接Dify API接口完整指南 一、Dify API简介 Dify是一款AI应用开发平台&#xff0c;提供多种自然语言处理能力。通过调用Dify开放API&#xff0c;开发者可以快速集成智能对话、文本生成等功能到自己的Java应用中。 二、准备工作 获取API密钥 登录Dify平台控制台在「API密…
阅读更多...
极狐GitLab GEO 功能介绍

极狐GitLab GEO 功能介绍

极狐GitLab 是 GitLab 在中国的发行版&#xff0c;关于中文参考文档和资料有&#xff1a; 极狐GitLab 中文文档极狐GitLab 中文论坛极狐GitLab 官网 Geo (PREMIUM SELF) Geo 是广泛分布的开发团队的解决方案&#xff0c;可作为灾难恢复策略的一部分提供热备份。Geo 不是 开箱…
阅读更多...
云原生（Cloud Native）的详解、开发流程及同类软件对比

云原生（Cloud Native）的详解、开发流程及同类软件对比

以下是云原生&#xff08;Cloud Native&#xff09;的详解、开发流程及同类软件对比&#xff1a; 一、云原生核心概念 定义&#xff1a; 云原生&#xff08;Cloud Native&#xff09;是基于云环境设计和运行应用程序的方法论&#xff0c;强调利用云平台的弹性、分布式和自动化…
阅读更多...
学习笔记：减速机工作原理

学习笔记：减速机工作原理

学习笔记&#xff1a;减速机工作原理 一、减速机图片二、减速比概念三、减速机的速比与扭矩之间的关系四、题外内容--电机扭矩 一、减速机图片 二、减速比概念 即减速装置的传动比&#xff0c;是传动比的一种&#xff0c;是指减速机构中&#xff0c;驱动轴与被驱动轴瞬时输入速…
阅读更多...
《UE5_C++多人TPS完整教程》学习笔记36 ——《P37 拾取组件（Pickup Widget）》

《UE5_C++多人TPS完整教程》学习笔记36 ——《P37 拾取组件（Pickup Widget）》

本文为B站系列教学视频 《UE5_C多人TPS完整教程》 —— 《P37 拾取组件&#xff08;Pickup Widget&#xff09;》 的学习笔记&#xff0c;该系列教学视频为计算机工程师、程序员、游戏开发者、作家&#xff08;Engineer, Programmer, Game Developer, Author&#xff09; Steph…
阅读更多...
《空间复杂度（C语言）》

《空间复杂度（C语言）》

文章目录 前言一、什么是空间复杂度&#xff1f;通俗理解&#xff1a; 二、空间复杂度的数学定义三、常见空间复杂度举例&#xff08;含C语言代码&#xff09;&#x1f539; O(1)&#xff1a;常数空间&#x1f539; O(n)&#xff1a;线性空间&#x1f539; O(n^2)&#xff1a;平…
阅读更多...
智能合约安全审计平台——以太坊虚拟机安全沙箱

智能合约安全审计平台——以太坊虚拟机安全沙箱

目录 以太坊虚拟机安全沙箱 —— 理论、设计与实战1. 引言2. 理论背景与安全原理2.1 以太坊虚拟机（EVM）概述2.2 安全沙箱的基本概念2.3 安全证明与形式化验证3. 系统架构与模块设计3.1 模块功能说明3.2 模块之间的数据流与安全性4. 安全性与密码学考量4.1 密码学保障在沙箱中…
阅读更多...
【MCP教程】Claude Desktop 如何连接部署在远程的remote mcp server服务器(remote host)

【MCP教程】Claude Desktop 如何连接部署在远程的remote mcp server服务器(remote host)

前言 最近MCP特别火热&#xff0c;笔者自己也根据官方文档尝试了下。 官方文档给的Demo是在本地部署一个weather.py&#xff0c;然后用本地的Claude Desktop去访问该mcp服务器&#xff0c;从而完成工具的调用&#xff1a; 但是&#xff0c;问题来了&#xff0c;Claude Deskto…
阅读更多...
多个路由器互通（静态路由）无单臂路由（简单版）

多个路由器互通（静态路由）无单臂路由（简单版）

多个路由器互通&#xff08;静态路由&#xff09;无单臂路由&#xff08;简单版&#xff09; 开启端口并配ip地址 维护1 Router>en Router#conf t Router(config)#int g0/0 Router(config-if)#no shutdown Router(config-if)#ip address 192.168.10.254 255.255.255.0 Ro…
阅读更多...
OpenCV 图形API（38）图像滤波-----Sobel 算子操作函数Sobel()

OpenCV 图形API（38）图像滤波-----Sobel 算子操作函数Sobel()

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 cv::gapi::Sobel 函数是 OpenCV 的 G-API 模块中用于执行 Sobel 算子操作的一个函数&#xff0c;主要用于图像的边缘检测。Sobel 算子通过计算图…
阅读更多...
windows系统安装驱动、cuda和cudnn

windows系统安装驱动、cuda和cudnn

一、首先在自己的电脑里安装了nvidia的独立显卡 显卡的查找方式&#xff1a; CtrlShiftEsc打开任务管理器&#xff0c;点击性能&#xff0c;点击GPU 0查看显卡型号&#xff0c;如下图所示&#xff1a; 只要电脑中有nvidia的独立显卡&#xff0c;就可以暗转显卡驱动、cuda和cu…
阅读更多...
嵌入式开发--STM32软件和硬件CRC的使用--续篇

嵌入式开发--STM32软件和硬件CRC的使用--续篇

本文是《嵌入式开发–STM32软件和硬件CRC的使用》的续篇&#xff0c;又踩到一个坑&#xff0c;发出来让大家避一下坑。 按照G0系列的设置&#xff0c;得出错误的结果 前文对应的是STM32G0系列&#xff0c;今天在用STM32G4系列时&#xff0c;按照前文的设置&#xff0c;用硬件…
阅读更多...
【Git】git的简单使用

【Git】git的简单使用

文章目录 1. 基础概念2. 简单使用2.1 git配置2.1.1 git的配置文件2.1.2 .gitignore文件 2.2 创建仓库2.2.1 创建本地仓库2.2.2 github创建远程仓库step1&#xff1a;github新建一个代码仓step2&#xff1a;创建密钥远程仓库相关指令2.2.3 本地仓库 关联 远程仓库 2.3 分支2.3.1…
阅读更多...
[Web 安全] Web 信息收集 —— 信息收集流程

[Web 安全] Web 信息收集 —— 信息收集流程

&#x1f31f; 想系统化学习 Web 渗透&#xff1f;看看这个&#xff1a;[Web 安全] Web 安全攻防 学习手册 提示&#xff1a;本章不涉及任何具体信息收集技术&#xff0c;仅仅是讲解收集这些信息我能干啥&#xff0c;以及如何才能比较全面的收集信息。 0x01&#xff1a;信息收…
阅读更多...
内部聊天软件，BeeWorks-安全的企业内部通讯软件

内部聊天软件，BeeWorks-安全的企业内部通讯软件

企业在享受数据便利的同时&#xff0c;如何保障企业数据安全已经成为无法回避的重要课题。BeeWorks作为一款专为企业设计的内部通讯软件&#xff0c;通过全链路的安全能力升维&#xff0c;为企业提供了一个安全、高效、便捷的沟通协作平台&#xff0c;全面保障企业数据安全。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023