链表练习题

作者前言

🎂 ✨✨✨✨✨✨🍧🍧🍧🍧🍧🍧🍧🎂
​🎂 作者介绍： 🎂🎂
🎂 🎉🎉🎉🎉🎉🎉🎉 🎂
🎂作者id：老秦包你会， 🎂
简单介绍：🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂
喜欢学习C语言和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂
🎂个人主页::小小页面🎂
🎂gitee页面:秦大大🎂
🎂🎂🎂🎂🎂🎂🎂🎂
🎂 一个爱分享的小博主 欢迎小可爱们前来借鉴🎂

练习

  • **作者前言**
  • 移除链表元素
  • 分割链表
  • 反向链表
  • 链表中倒数第k个结点
  • 相交链表
  • 环形链表
  • 环形链表 II
  • 合并两个有序链表
  • 链表的回文结构
  • 随机链表的复制

移除链表元素

移除链表元素
在这里插入图片描述
这道题有多种思路，双指针法
思路：遍历一遍，在中途中我们要找出要删除的节点，并把要删除的节点进行free，我们要注意的就是
在这里插入图片描述
我们通过判断tail->val是否为要删除的值,如果不是就prev = tail, tail = tail->next,如果是的话,我们就要删除, 然后tail存储下一个节点的地址,而prev不变,
我们要考虑一些情况,当我们删除的是第一个节点,那head存储的地址就要改变,
循环结束的条件就是
在这里插入图片描述

tail的值为NULL,就是循环停止的时候

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val)
{
    struct ListNode* cur = head;
    struct ListNode* prev = NULL;
    //遍历一遍
    while (cur)
    {
        if (cur->val == val)
        {
            struct ListNode* nex = cur->next;
            if (prev)
            {
                prev->next = nex;
            }
            //判断是否要删除第一个节点
            else
            {
                head = nex;
            }

            free(cur);
            cur = nex;

        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
    return head;
}

二指针加空链表法(尾插思路)
在这里插入图片描述

cur去判断该节点是否符合,引用新的newhead指向符合条件的节点,符合就添加到newhead,不是就free,然后cur指向下一个节点,tail不动,有两种特殊情况,一种的head=NULL,一种是free最后一个节点,前一个节点的next没有NULL

struct ListNode* removeElements(struct ListNode* head, int val)
{
    struct ListNode* newnode = NULL;
    struct ListNode* cur = head;
    struct ListNode* tail = NULL;
    while (cur)
    {
        if (cur->val != val)
        {
            if (tail == NULL)
            {
                newnode = cur;
                tail = cur;
            }
            else
            {
                tail->next = cur;
                tail = cur;
                
            }
            cur = cur->next;
        }
        else
        {
            //保存下一个节点
            struct ListNode* p = cur->next;
            free(cur);
            cur = p;
        }
    }
    //假设head为NULL
    if (tail)
        tail->next = NULL;
    return newnode;
 }

哨兵位方法
在这里插入图片描述
这里的头节点不是d1而是head也称哨兵位头节点
这个带哨兵位的链表的好处就是头节点一定存在,地址不为空,
在这里插入图片描述

struct ListNode* removeElements(struct ListNode* head, int val)
{
    //创建哨兵位
    struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* cur = head;
    struct ListNode* tail = newnode;
    while (cur)
    {
        if (cur->val != val)
        {
           tail->next = cur;
           cur = cur->next;
           tail = tail->next;
        }
        else
        {
            //保存下一个节点
            struct ListNode* p = cur->next;
            free(cur);
            cur = p;
        }
    }
    //假设head为NULL
    tail->next = NULL;
    //释放哨兵
    struct ListNode*p = newnode->next;
    free(newnode);
    return p;
  }

分割链表

分割链表
在这里插入图片描述
方法1:创建两个空链表 链表1存储小于X的所有节点，链表2存储大于等于x的所有节点，然后两个链表链接起来，
在这里插入图片描述

 ListNode* partition(ListNode* pHead, int x) 
    {
        //小
        struct ListNode *head1 = (struct ListNode *)malloc(sizeof(struct ListNode));
        struct ListNode *tail1 = head1;
        //大
        struct ListNode *head2 = (struct ListNode *)malloc(sizeof(struct ListNode));
        struct ListNode *tail2 = head2;
        struct ListNode *cur = pHead;
        while (cur) 
        {
            if(cur->val < x)
            {
                tail1->next = cur;
                tail1 = tail1->next;
            }
            else
            {
                tail2->next = cur;
                tail2 = tail2->next;
            }
            cur = cur->next;
        
        }
        //防止head2最后一个节点的next不为NULL
        tail2->next = NULL;
        tail1->next = head2->next;
        struct ListNode *ph = head1->next;
        free(head1);
        free(head2);
        return ph;

       
    }

我们需要注意的是head2的最后一个节点的next可能指向野指针,也可能形成环状链表,

反向链表

反向链表
在这里插入图片描述
方法1
三指针反转
在这里插入图片描述
主要进行交换的是n1和n2这两个指针,n3指针是辅助n2能找到下一个节点的地址
循环结束就是
在这里插入图片描述
当n2 = NULL或者是n1->next = NULL循环结束

struct ListNode* reverseList(struct ListNode* head) 
{
    if (head == NULL)
        return head;
    struct ListNode *n1 = NULL;
    struct ListNode *n2 = head;
    struct ListNode *n3 = head->next;
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if(n3)
            n3 = n3->next;
    }
    return n1;
}

方法二:创建空链表,头插
在这里插入图片描述
思路:把旧链表的节点取下来,然后头插到新链表中

struct ListNode* reverseList(struct ListNode* head) 
{
    struct ListNode* newnode = NULL;
    struct ListNode* cur = head;
    while(cur)
    {
         struct ListNode* pn = cur->next;
        cur->next = newnode;
        newnode = cur;
        cur = pn;
    }
    return newnode;
}

链表中倒数第k个结点

链表中倒数第k个结点
在这里插入图片描述
方法1暴力法
先求出链表的长度,然后长度减去倒数的个数,再遍历一遍

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* tail = pListHead;
    if (tail) {
        int size = 1;
        while (tail->next) {
            tail = tail->next;
            size++;

        }
        tail = pListHead;
        if (k > size) {
            return NULL;
        }
        while (size > k) {
            tail = tail->next;
            size--;
        }

        return tail;
    }
    else {
    return NULL;
    }
}

时间复杂度是O(n)
但是不够高效

方法二
双指针距离差
创建两个指针,指向头节点,然后一个一个节点也走k步,然后两个指针一起走,当走k步的那个指针为NULL就结束
在这里插入图片描述

结束标记
在这里插入图片描述

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast = pListHead, *slow = pListHead;
    //fast先走k步
    while(k--)
    {
        //防止为空
        if(fast ==NULL)
            return NULL;
        fast = fast->next;
    }
    //一起走
    while (fast) 
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

相交链表

相交链表
在这里插入图片描述
方法1:暴力法
A中的每个节点的地址在B链表都找一遍,然后比较,时间复杂度是O(n^2)

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
 {
     struct ListNode* taila = headA;
     
     while(taila)
     {
         struct ListNode* tailb = headB;
         while(tailb)
         {
             if(taila == tailb)
             {
                 return tailb;
             }
             tailb = tailb->next;
         }
         taila = taila->next;
     }
    return NULL;
}

方法2
两个链表遍历一遍，然后找出尾节点进行比较地址，相同则继续计算长度，长度大的先走，走到剩下的长度和另外一个链表的长度一样，然后一起走，然后一一比较节点的地址
​在这里插入图片描述

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
 {
     if(!(headA && headB))
        return NULL;
    struct ListNode* tail1 = headA;
    struct ListNode* tail2 = headB;
    int conut1 =1;
    int conut2 =1;
    //找出尾节点,随便算出cah
    while(tail1->next)
    {
        tail1 = tail1->next;
        conut1++;
    }
    while(tail2->next)
    {
        tail2 = tail2->next;
        conut2++;
    }
    if(!(tail1 == tail2))
        return NULL;
    struct ListNode* maxh = (conut1 >= conut2 ? headA : headB);
     struct ListNode* minh = (conut1 >= conut2 ? headB : headA);
    int i = 0;
    for (i = 0; i <abs(conut1 -conut2);i++)
    {
        maxh = maxh->next;
    }
    while(minh)
    {
        if(maxh == minh)
        {
            return maxh;
        }
        maxh = maxh->next;
        minh = minh->next;
    }
    return NULL;
}

环形链表

环形链表
在这里插入图片描述
这里考察带环链表
代环链表:尾节点的next指向链表的任意节点
看到这里可能会想到遍历一遍,找出尾节点,这样很容易陷入死循环,或者有人想到找节点比较,怎么找,因为节点是不确定的,无法这样
这个题可以使用漏洞法

bool hasCycle(struct ListNode *head) 
{
    struct ListNode*tail = head;
    int a = 10002;
    while(tail)
    {
        if(a==0)
            return true;
        a--;
        tail = tail->next;

    }
    return false;
}

在这里插入图片描述
可以判断如果循环次数超出节点数就可以判断是有环的,否则就是无环的这种方法不推荐

方法2:快慢指针速度差法
在这里插入图片描述
slow一次走一步，fast一次走两步,当slow刚刚进入到环里面时

fast和slow的距离就是X,转换成fast追逐slow
v1 t - v2t = X, t = x/(v1 - v2)


bool hasCycle(struct ListNode *head) 
{
    struct ListNode* slow = head, *fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
            return true;
    }
    return false;
}

环形链表 II

环形链表 II
在这里插入图片描述
思路:
快慢指针求出相遇点
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

slow一次走一步，fast一次走两步,当slow刚刚进入到环里面时,fast和slow的距离就是X,转换成slow和fast在入环点的经过x的长度相遇,c为环的长度
写成 2(L+x) = n*c + L +x
化简成L = (n-1)*c + c - x
在这里插入图片描述
所以我们求出入环点可以这样,一个指针在fast和slow相遇的节点开始循环,一个指针从头节点开始走,最终一定会在入环点相遇

struct ListNode *detectCycle(struct ListNode *head) 
{
    if(head == NULL)
        return NULL;
    struct ListNode*tail = head;
    struct ListNode*prev = head;
    //找出相遇点
    while (prev && prev->next)
    {
       
        tail = tail->next;
        prev = prev->next ->next;
        //找出相遇点
        if(tail == prev)
        { //开始两个指针走
            tail = head;
            while(tail != prev)
            {
                tail = tail->next;
                prev = prev->next;
            }
            return tail;
        }
    }

    return NULL;  
}

转换相交链表解决
先找出相遇点,然后一个指针指向相遇点的下一个节点,把相遇点的next =NULL,然后一个指针从head开始走,变成找两链表找交点

 struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
 {
     if(!(headA && headB))
        return NULL;
    struct ListNode* tail1 = headA;
    struct ListNode* tail2 = headB;
    int conut1 =1;
    int conut2 =1;
    //找出尾节点,随便算出cah
    while(tail1->next)
    {
        tail1 = tail1->next;
        conut1++;
    }
    while(tail2->next)
    {
        tail2 = tail2->next;
        conut2++;
    }
    if(!(tail1 == tail2))
        return NULL;
    struct ListNode* maxh = (conut1 >= conut2 ? headA : headB);
     struct ListNode* minh = (conut1 >= conut2 ? headB : headA);
    int i = 0;
    for (i = 0; i <abs(conut1 -conut2);i++)
    {
        maxh = maxh->next;
    }
    while(minh)
    {
        if(maxh == minh)
        {
            return maxh;
        }
        maxh = maxh->next;
        minh = minh->next;
    }
    return NULL;
}
struct ListNode *detectCycle(struct ListNode *head) 
{
    if(head == NULL)
        return NULL;
    struct ListNode*tail = head;
    struct ListNode*prev = head;
    //找出相遇点
    while (prev && prev->next)
    {
       
        tail = tail->next;
        prev = prev->next ->next;
        //找出相遇点
        if(tail == prev)
        { //开始两个指针走
            tail = head;
            struct ListNode*p = prev->next;
            prev->next = NULL;
            p = getIntersectionNode(tail, p);
            if(p)
                return p;
        }
    }

    return NULL;  
}

合并两个有序链表

合并两个有序链表
在这里插入图片描述
思路:这里的思路和顺序表的(两顺序表合成一个顺序表)很像,创建两个指针分别指向l1和l2的头节点,创建一个空链表和一个指针,l1和l2的链表的节点进行判断,然后放入到空链表中,然后把剩下的节点一并插入到链表中
这里的空链表可以是带哨兵位的也可以不要

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    if(list1 == NULL)
        return list2;
    if(list2 == NULL)
        return list1;
    struct ListNode*newnode =NULL;
    struct ListNode*prev =NULL;
    struct ListNode* tail1 = list1;
    struct ListNode* tail2 = list2;
    while(tail1 && tail2)
    {
        if(tail1->val < tail2->val)
        {
            if(prev == NULL)
            {
                newnode = tail1;
                prev = tail1;
                tail1 = tail1->next;
            }
            else
            {
                prev->next = tail1;
                prev = prev->next;
                tail1 = tail1->next;
            }
        }
        else
        {
            if(prev == NULL)
            {
                newnode = tail2;
                prev = tail2;
                tail2 = tail2->next;
            }
            else
            {
                prev->next = tail2;
                prev = prev->next;
                tail2 = tail2->next;
            }
        }
    } 
    if(tail1)
        prev->next = tail1;
    if(tail2)
        prev->next = tail2;
    return newnode;








    // if(list1 == NULL)
    //     return list2;
    // if(list2 == NULL)
    //     return list1;
    // //哨兵位
    // struct ListNode *newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
    // struct ListNode* tail1 = list1;
    // struct ListNode* tail2 = list2;
    // struct ListNode* prev = newnode;
    // while(tail1 && tail2)
    // {
    //     if(tail1->val > tail2->val)
    //     {
    //         prev->next = tail2;
    //         tail2 = tail2->next;
    //     }
    //     else
    //     {
    //         prev->next = tail1;
    //         tail1 = tail1->next;
    //     }
    //     prev = prev->next;
    // }
    // if(tail1)
    //     prev->next = tail1;
    // if(tail2)
    //     prev->next = tail2;
    // struct ListNode *ph = newnode->next;
    // free(newnode);
    // return ph;
}

链表的回文结构

链表的回文结构

在这里插入图片描述
思路:我们可以先找到这个链表的中间节点,然后把后半段的链表逆置过来,然后转换成两个链表(节点数一样的)对应的节点一一比较
在这里插入图片描述

class PalindromeList {
public:
    bool chkPalindrome(ListNode* head) 
    {
         if(head == NULL)
            return true;
        //双指针速度差法
       
        struct ListNode *slow = head, *fast = head;
        while(fast && fast->next)
        {
            fast = fast ->next ->next;
            slow = slow->next;
        }
        //slow为中间节点
        //后部分反转
    
    struct ListNode *n1 = NULL;
    struct ListNode *n2 = slow;
    struct ListNode *n3 = slow->next;
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if(n3)
            n3 = n3->next;
    }
   
        //fast为第二个链表头节点地址
        fast = n1;
        slow = head;
        while(slow && fast)
        {
            if(slow->val != fast->val)
            {
                return false;
            }
            slow = slow->next;
            fast = fast->next;
            
        }
        return true;
        
        //双指针比较
    }
};

随机链表的复制

随机链表的复制
在这里插入图片描述
思路:
在这里插入图片描述
我们可以像上图一样,往每个原节点的后面插入一个和该节点相同值的节点,然后我们在原节点的找到random, 每个原节点的后一个节点就是复制的节点,我们可以通过这种特性把复制的节点的random进行连接,然后创建一个空链表,把复制的节点进行连接,

struct Node* copyRandomList(struct Node* head) 
{
    if(head == NULL)
        return NULL;
    struct Node *cur = head;
    while(cur)
    {
        //创建节点
        struct Node *copy = (struct Node *)malloc(sizeof(struct Node));
        copy->val = cur->val;
        struct Node *cp = cur->next;
        cur->next = copy;
        copy->next = cp;
        cur = cp;
    }
    //开始指向random
    cur = head;
   
    while(cur)
    {
         struct Node *cp = cur->next;
        if(cur->random)
            cp->random = cur->random->next;
        else
            cp->random = NULL;
        cur = cur->next->next;
        

    }
    //创建空链表,然后尾插
    //创建哨兵位
    struct Node *newnode = (struct Node *)malloc(sizeof(struct Node));
     struct Node *tail = newnode;
    //开始尾插
    cur = head;
    while(cur)
    {
        struct Node *new = cur->next;
        tail->next = new;
        tail = tail->next;
        cur = new->next;
    }
   
    struct Node *p = newnode->next;
    free(newnode);
    return p;
}

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

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

相关文章

时间序列预测实战(十一)用SCINet实现滚动预测功能(附代码+数据集+原理介绍）

时间序列预测实战(十一)用SCINet实现滚动预测功能(附代码+数据集+原理介绍）

论文地址->SCINet官方论文地址 官方代码地址-> 官方代码下载地址 个人整理的代码地址->免费分享给大家创作不易请大家给文章点点赞 一、本文介绍 这篇文章给大家带来的是关于SCINet实现时间序列滚动预测功能的讲解&#xff0c;SCINet是样本卷积交换网络的缩写(Sam…
阅读更多...
devops完整搭建教程（gitlab、jenkins、harbor、docker）

devops完整搭建教程（gitlab、jenkins、harbor、docker）

devops完整搭建教程&#xff08;gitlab、jenkins、harbor、docker&#xff09; 文章目录 devops完整搭建教程&#xff08;gitlab、jenkins、harbor、docker&#xff09;1.简介&#xff1a;2.工作流程&#xff1a;3.优缺点4.环境说明5.部署前准备工作5.1.所有主机永久关闭防火墙…
阅读更多...
HTTPS的工作流程

HTTPS的工作流程

. HTTPS是什么&#xff1f; https是应用层中的一个协议&#xff0c;是在http协议的基础上引入的一个加密层。 为什么需要HTTPS 由于http协议内容都是按照文本的方式明文传输的&#xff0c;这就导致传输过程中会出现一些被篡改的情况。运营商劫持事件最开始百度&#xff0c;…
阅读更多...
比较PID控制和神经网络控制在机器人臂上的应用

比较PID控制和神经网络控制在机器人臂上的应用

机器人臂是自动化领域中常见的机器人形式&#xff0c;其精确控制对于实现复杂任务具有重要意义。在机器人臂的控制中&#xff0c;PID控制和神经网络控制是两种常用的控制方法。本文将比较PID控制和神经网络控制在机器人臂控制方面的应用&#xff0c;包括控制原理、优缺点以及在…
阅读更多...
【广州华锐互动】太空探索VR模拟仿真教学系统

【广州华锐互动】太空探索VR模拟仿真教学系统

随着科技的不断发展&#xff0c;人类对宇宙的探索欲望愈发强烈。火星作为距离地球最近的行星之一&#xff0c;自然成为了人类关注的焦点。近年来&#xff0c;火星探测取得了一系列重要成果&#xff0c;为人类了解火星提供了宝贵的信息。然而&#xff0c;实地考察火星仍然面临着…
阅读更多...
C++——基础

C++——基础

初学C的时候&#xff0c;有没有想过&#xff0c;为什么C支持重载&#xff0c;而C不支持重载呢&#xff1f;&#xff1f; 其实&#xff0c;一个程序运行起来都要经过四步骤 预处理编译汇编链接 预处理阶段会经过去注释&#xff0c;宏替换&#xff0c;头文件展开&#xff0c;条…
阅读更多...
Liunx终极环境搭建

Liunx终极环境搭建

华子目录 网络服务准备工作安装RHEL9系统部署RHEL9操作系统虚拟网络编辑器配置RHEL9系统系统中的设置更换yum源修改主机名关闭selinux&#xff0c;firewalld设置静态ip &#xff08;网络配置&#xff09; 网络服务 准备工作 以下为RHEL9镜像资源&#xff0c;有需要的博友们可…
阅读更多...
Ubuntu(WSL) mysql8.0.31 源码安装

Ubuntu(WSL) mysql8.0.31 源码安装

要在 Ubuntu 上使用调试功能安装 MySQL 8.0 的源码&#xff0c;可以按照以下详细步骤进行操作&#xff1a; 1. 更新系统 首先&#xff0c;确保你的 Ubuntu 系统是最新的。运行以下命令更新系统软件包&#xff1a; sudo apt update sudo apt upgrade 2. 下载 MySQL 源码 访…
阅读更多...
ChatGPT Plus的Vision升级是一个改变游戏规则的创举

ChatGPT Plus的Vision升级是一个改变游戏规则的创举

内容来源&#xff1a;0xluffy_eth ChatGPT Plus的Vision升级是一个改变游戏规则的创举&#xff01; 现在每个用户都可以以每月20美元的价格雇用自己的个人数字助理实习生&#xff0c;具备VISION&#xff01; 以下是10个惊人的例子&#xff08;&#xff09; 1&#xff0c; 我…
阅读更多...
Blender--》点线面操作及其面操作的详解

Blender--》点线面操作及其面操作的详解

接下来我会在three.js专栏中分享关于3D建模知识的文章&#xff0c;如果学习three朋友并且想了解和学习3D建模&#xff0c;欢迎关注本专栏&#xff0c;关于这款3D建模软件blender的安装&#xff0c;我在前面的文章已经讲解过了&#xff0c;如果不了解的朋友可以去考考古&#xf…
阅读更多...
this和super

this和super

文章目录 this用法普通的直接引用区分形参与实参 super用法普通的直接引用区分子类与父类同名的属性或方法 this和super 与 构造方法总结 this this引用表示当前对象对象的引用。 用法 普通的直接引用 public class Test {int a ;int b;public Test() {this.b 0;} }调用当…
阅读更多...
mysql的sql_mode参数

mysql的sql_mode参数

msql修改了这个参数&#xff0c;首先mysql需要重新才能生效&#xff0c;还有就是java连接的springboot项目也需要重新启动。之前是遇到了下面的这个报错。只需要把sql_mode设置为空&#xff0c;重启mysql和服务就行 报错 In aggregated query without GROUP BY, expression #1…
阅读更多...
使用 pubsub-js 进行消息发布订阅

使用 pubsub-js 进行消息发布订阅

npm 包地址 github 包地址 pubsub-js 是一个轻量级的 JavaScript 基于主题的消息订阅发布库 &#xff0c;压缩后小于1b。它具有使用简单、性能高效、支持多平台等优点&#xff0c;可以很好地满足各种需求。 功能特点&#xff1a; 无依赖同步解耦ES3 兼容。pubsub-js 能够在…
阅读更多...
Vatee万腾外汇数字化策略：Vatee科技决策力的未来引领

Vatee万腾外汇数字化策略：Vatee科技决策力的未来引领

在外汇市场&#xff0c;Vatee万腾通过其前瞻性的外汇数字化策略&#xff0c;正引领着科技决策的未来。这一数字化策略的崭新愿景为投资者提供了更智慧、更高效的外汇投资体验&#xff0c;成为科技决策领域的翘楚。 Vatee万腾的外汇数字化策略是科技决策力未来引领的典范。通过运…
阅读更多...
C# PaddleInference.PP-HumanSeg 人像分割 替换背景色

C# PaddleInference.PP-HumanSeg 人像分割 替换背景色

效果 项目 VS2022.net4.8OpenCvSharp4Sdcb.PaddleInference 包含4个分割模型 modnet-hrnet_w18 modnet-mobilenetv2 ppmatting-hrnet_w18-human_512 ppmattingv2-stdc1-human_512 代码 using OpenCvSharp; using Sdcb.PaddleInference; using System; using System.Col…
阅读更多...
Springboot SpringCloudAlibaba Nacos 项目搭建

Springboot SpringCloudAlibaba Nacos 项目搭建

依赖版本&#xff1a; spring-boot&#xff1a;2.3.12.RELEASE spring-cloud-alibaba&#xff1a;2.2.7.RELEASE spring-cloud&#xff1a;Hoxton.SR12 nacos&#xff1a;2.0.3 1.部署搭建Nacos注册中心 Linux Nacos 快速启动_nacos linux快速启动-CSDN博客 2.构建项目 源码地…
阅读更多...
STM32——STM32F4系统架构

STM32——STM32F4系统架构

文章目录 前言STM32F4XX系统架构 前言 本篇文章为STM32F4系列的系统架构&#xff0c;因为最近在学习F4的板子&#xff0c;暂时先更F4的&#xff0c;有需要F1的后续再更新。 主系统由 32 位多层 AHB 总线矩阵构成&#xff0c;可实现以下部分的互连&#xff1a; STM32F4XX系统架…
阅读更多...
19. 深度学习 - 用函数解决问题

19. 深度学习 - 用函数解决问题

文章目录 Hi&#xff0c; 你好。我是茶桁。 上一节课&#xff0c;我们从一个波士顿房价的预测开始写代码&#xff0c;写到了KNN。 之前咱们机器学习课程中有讲到KNN这个算法&#xff0c;分析过其优点和缺点&#xff0c;说起来&#xff0c;KNN这种方法比较低效&#xff0c;在数…
阅读更多...
万能在线预约小程序系统源码 适合任何行业在线预约小程序+预约到店模式 带完整的搭建教程

万能在线预约小程序系统源码 适合任何行业在线预约小程序+预约到店模式 带完整的搭建教程

大家好啊&#xff0c;源码小编又来给大家分享啦&#xff01;随着互联网的发展和普及&#xff0c;越来越多的服务行业开始使用在线预约系统以方便客户和服务管理。例如&#xff0c;美发店、健身房、餐厅等都可以通过在线预约系统提高服务效率&#xff0c;减少等待时间&#xff0…
阅读更多...
开机自启动笔记本的小键盘

开机自启动笔记本的小键盘

虽然电脑开机次数不多&#xff0c;但每次开机都要摁下小键盘的开关&#xff0c;好烦 终于忍不住了&#xff1a; 将下面文件命名为 XXX.bat echo off rem 禁用批处理文件中的命令回显&#xff0c;以使输出更整洁rem 查询注册表中 "InitialKeyboardIndicators" 的值 r…
阅读更多...
最新文章

Copyright @ 2022~2023