【C++代码】链表

news2024/11/17 10:04:00

  • 算法：搜索、查找、排序、双指针、回溯、分治、动态规划、贪心、位运算、数学等。

  • 数据结构：数组、栈、队列、字符串、链表、树、图、堆、哈希表等。

  • 数据结构是为实现对计算机数据有效使用的各种数据组织形式，服务于各类计算机操作。不同的数据结构具有各自对应的适用场景，旨在降低各种算法计算的时间与空间复杂度，达到最佳的任务执行效率。常见的数据结构可分为「线性数据结构」与「非线性数据结构」，具体为：「数组」、「链表」、「栈」、「队列」、「树」、「图」、「散列表」、「堆」。数组是将相同类型的元素存储于连续内存空间的数据结构，其长度不可变。链表以节点为单位，每个元素都是一个独立对象，在内存空间的存储是非连续的。链表的节点对象具有两个成员变量：「值 val」，「后继节点引用 next」 。栈是一种具有 「先入后出」 特点的抽象数据结构，可使用数组或链表实现。通过常用操作「入栈 push()」,「出栈 pop()」，展示了栈的先入后出特性。队列是一种具有 「先入先出」 特点的抽象数据结构，可使用链表实现。通过常用操作「入队 push()」,「出队 pop()」，展示了队列的先入先出特性。

  • 树是一种非线性数据结构，根据子节点数量可分为 「二叉树」 和 「多叉树」，最顶层的节点称为「根节点 root」。以二叉树为例，每个节点包含三个成员变量：「值 val」、「左子节点 left」、「右子节点 right」 。图是一种非线性数据结构，由「节点（顶点）vertex」和「边 edge」组成，每条边连接一对顶点。根据边的方向有无，图可分为「有向图」和「无向图」。

    • 在这里插入图片描述

    • 表示图的方法通常有两种：邻接矩阵： 使用数组 vertices 存储顶点，邻接矩阵 edges 存储边；edges[i] [j] 代表节点 i+1 和 节点 j+1 之间是否有边。

    • vertices = [1, 2, 3, 4, 5]
edges = [[0, 1, 1, 1, 1],
         [1, 0, 0, 1, 0],
         [1, 0, 0, 0, 1],
         [1, 1, 0, 0, 1],
         [1, 0, 1, 1, 0]]

    • 邻接表： 使用数组 vertices 存储顶点，邻接表 edges 存储边。 edges 为一个二维容器，第一维 i 代表顶点索引，第二维 edges[i] 存储此顶点对应的边集和；例如 edges[0]=[1,2,3,4] 代表 vertices[0] 的边集合为 [1,2,3,4] 。

    • vertices = [1, 2, 3, 4, 5]
edges = [[1, 2, 3, 4],
         [0, 3],
         [0, 4],
         [0, 1, 4],
         [0, 2, 3]]

    • 邻接矩阵 VS 邻接表 ：

      邻接矩阵的大小只与节点数量有关，即 N 2 N^2 N2 ，其中 N 为节点数量。因此，当边数量明显少于节点数量时，使用邻接矩阵存储图会造成较大的内存浪费。因此，邻接表 适合存储稀疏图（顶点较多、边较少）； 邻接矩阵 适合存储稠密图（顶点较少、边较多）。

  • 散列表是一种非线性数据结构，通过利用 Hash 函数将指定的「键 key」映射至对应的「值 value」，以实现高效的元素查找。则可通过建立姓名为 key ，学号为 value 的散列表实现此需求，代码如下：

    • # 初始化散列表
dic = {}
# 添加 key -> value 键值对
dic["小力"] = 10001
dic["小特"] = 10002
dic["小扣"] = 10003
# 从姓名查找学号
dic["小力"] # -> 10001
dic["小特"] # -> 10002
dic["小扣"] # -> 10003

    • 实际的 Hash 函数需保证低碰撞率、 高鲁棒性等，以适用于各类数据和场景。

  • 堆是一种基于「完全二叉树」的数据结构，可使用数组实现。以堆为原理的排序算法称为「堆排序」，基于堆实现的数据结构为「优先队列」。堆分为「大顶堆」和「小顶堆」，大（小）顶堆：任意节点的值不大于（小于）其父节点的值。

    • 完全二叉树定义： 设二叉树深度为 k ，若二叉树除第 k 层外的其它各层（第 1 至 k−1 层）的节点达到最大个数，且处于第 k 层的节点都连续集中在最左边，则称此二叉树为完全二叉树。

  • 为包含 1, 4, 2, 6, 8 元素的小顶堆。将堆（完全二叉树）中的结点按层编号，即可映射到右边的数组存储形式。

    • 在这里插入图片描述

    • 通过使用「优先队列」的「压入 push()」和「弹出 pop()」操作，即可完成堆排序，实现代码如下：

    • from heapq import heappush, heappop
# 初始化小顶堆
heap = []
# 元素入堆
heappush(heap, 1)
heappush(heap, 4)
heappush(heap, 2)
heappush(heap, 6)
heappush(heap, 8)
# 元素出堆（从小到大）
heappop(heap) # -> 1
heappop(heap) # -> 2
heappop(heap) # -> 4
heappop(heap) # -> 6
heappop(heap) # -> 8

  • 算法复杂度旨在计算在输入数据量 N 的情况下，算法的「时间使用」和「空间使用」情况；体现算法运行使用的时间和空间随「数据大小 N 」而增大的速度。算法复杂度主要可从 时间 、空间 两个角度评价：

    • 时间： 假设各操作的运行时间为固定常数，统计算法运行的「计算操作的数量」 ，以代表算法运行所需时间；

    • 空间： 统计在最差情况下，算法运行所需使用的「最大空间」；

    • 根据输入数据的特点，时间复杂度具有「最差」、「平均」、「最佳」三种情况，分别使用 O , Θ , Ω 三种符号表示。

    • 根据从小到大排列，常见的算法时间复杂度主要有：

    • O ( 1 ) < O ( l o g N ) < O ( N ) < O ( N l o g N ) < O ( N 2 ) < O ( 2 N ) < O ( N ! ) O(1)<O(logN)<O(N)<O(NlogN)<O(N^2)<O(2^N)<O(N!) O(1)<O(logN)<O(N)<O(NlogN)<O(N2)<O(2N)<O(N!)

    • 在这里插入图片描述

    • 空间复杂度涉及的空间类型有：

      • 输入空间： 存储输入数据所需的空间大小；
      • 暂存空间： 算法运行过程中，存储所有中间变量和对象等数据所需的空间大小；
      • 输出空间： 算法运行返回时，存储输出数据所需的空间大小；

    • 通常情况下，空间复杂度指在输入数据大小为 N 时，算法运行所使用的「暂存空间」+「输出空间」的总体大小。

  • 编译后，程序指令所使用的内存空间。算法中的各项变量使用的空间，包括：声明的常量、变量、动态数组、动态对象等使用的内存空间。程序调用函数是基于栈实现的，函数在调用期间，占用常量大小的栈帧空间，直至返回后释放。

  • 对于算法的性能，需要从时间和空间的使用情况来综合评价。优良的算法应具备两个特性，即时间和空间复杂度皆较低。而实际上，对于某个算法问题，同时优化时间复杂度和空间复杂度是非常困难的。降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。

题目：书店店员有一张链表形式的书单，每个节点代表一本书，节点中的值表示书的编号。为更方便整理书架，店员需要将书单倒过来排列，就可以从最后一本书开始整理，逐一将书放回到书架上。请倒序返回这个书单链表。

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<int> reverseBookList(ListNode* head) {
        stack<int> st;
        vector<int> ve;
        while(head){
            st.push(head->val);
            head = head->next;
        }
        while(!st.empty()){
            ve.push_back(st.top());
            st.pop();
        }
        return ve;

    }
};

  • 反转的实现就是一点小技巧，需要用到三个指针变量，类似于两个数交换的思想，层次递进。现在假设定义pre、phead、temp三个指针变量，用phead指向链表的头结点，而pre代表phead的前一个节点。具体实现代码如下：

    • ListNode* InvertList(link head){
	ListNode* pre,phead,temp;
	phead = &head;  //将phead指向链表头，做游标使用
	pre = NULL;  //pre为头指针之前的节点
	while(phead != NULL){
		temp = pre;
		pre = phead;
		phead = phead->next;
		pre->next = temp;  //pre接到之前的节点 
	}
	return pre; 
}

  • 利用递归，先递推至链表末端；回溯时，依次将节点值加入列表，即可实现链表值的倒序输出。

    • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<int> res;
    void track(ListNode* head){
        if(head==nullptr){
            return ;
        }
        track(head->next);
        res.push_back(head->val);
    }
    vector<int> reverseBookList(ListNode* head) {
        track(head);
        return res;
    }
};

题目：给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode* prenode = new ListNode(-1);
        prenode->next = head;
        ListNode* temp = prenode;
        while(temp->next){
            if(temp->next->val == val){
                temp->next = temp->next->next;
                break;
            }
            temp = temp->next;
        }
        return prenode->next;
    }
};

  • 本题删除值为 val 的节点分需为两步：定位节点、修改引用。定位节点： 遍历链表，直到 head.val == val 时跳出，即可定位目标节点。修改引用： 设节点 cur 的前驱节点为 pre ，后继节点为 cur.next ；则执行 pre.next = cur.next ，即可实现删除 cur 节点。对于头节点没有前驱，可以设置一个虚拟节点。

题目：给定一个头节点为 head 的单链表用于记录一系列核心肌群训练编号，请将该系列训练编号 倒序 记录于链表并返回。

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* trainningPlan(ListNode* head) {
        ListNode *pre,*cur;
        pre = nullptr;
        cur = head;
        while(head){
            cur = head;
            head = head->next;
            cur->next = pre;
            pre = cur;
        }
        return pre;
    }
};

  • 时间复杂度 O(N) ： 遍历链表使用线性大小时间。空间复杂度 O(1) ： 变量 pre 和 cur 使用常数大小额外空间。

题目：给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号，请查找并返回倒数第 cnt 个训练项目编号。

  • /**
 * Definition for singly-linked list.
* struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* trainingPlan(ListNode* head, int cnt) {
        int n=0;
        ListNode* node = nullptr;
        for(node=head;node;node=node->next){
            n++;
        }
        for(node = head;n>cnt;n--){
            node = node->next;
        }
        return node;
    }
};

  • 两次遍历，用双指针只需要一次遍历

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* trainingPlan(ListNode* head, int cnt) {
        ListNode* left =head;
        ListNode* right = head;
        while(right && cnt>0){
            right = right->next;
            cnt--;
        }
        while(right){
            right = right->next;
            left = left->next;
        }
        return left;
    }
};

题目：给定两个以 有序链表 形式记录的训练计划 l1、l2，分别记录了两套核心肌群训练项目编号，请合并这两个训练计划，按训练项目编号 升序 记录于链表并返回。注意：新链表是通过拼接给定的两个链表的所有节点组成的。

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* trainningPlan(ListNode* l1, ListNode* l2) {
        if(!l1){
            return l2;
        }
        if(!l2)
            return l1;
        ListNode* res;
        ListNode* head;
        if(l1->val < l2->val){
            head = l1;
            l1 = l1->next;
        }else{
            head = l2;
            l2 = l2->next;
        }
        res = head;
        while(l1 && l2){
            if(l1->val < l2->val){
                res->next = l1;
                l1 = l1->next;
            }else{
                res->next = l2;
                l2 = l2->next;
            }
            res = res->next;
        }
        if(l1){
            res->next = l1;
        }
        if(l2){
            res->next = l2;
        }
        return head;
    }
};

  • 链表 l1 , l2 是 递增 的，因此容易想到使用双指针 l1 和 l2 遍历两链表，根据 l1.val 和 l2.val 的大小关系确定节点添加顺序，两节点指针交替前进，直至遍历完毕。引入伪头节点： 由于初始状态合并链表中无节点，因此循环第一轮时无法将节点添加到合并链表中。解决方案：初始化一个辅助节点 dum 作为合并链表的伪头节点，将各节点添加至 dum 之后。

  • 在这里插入图片描述

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* trainningPlan(ListNode* l1, ListNode* l2) {
        ListNode* dumy = new ListNode(0);
        ListNode* cur =dumy;
        while(l1 && l2){
            if(l1->val < l2->val){
                cur->next = l1;
                l1 = l1->next;
            }else{
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        cur->next = l1!=nullptr?l1:l2;
        return dumy->next;
    }
};

题目：某教练同时带教两位学员，分别以链表 l1、l2 记录了两套核心肌群训练计划，节点值为训练项目编号。两套计划仅有前半部分热身项目不同，后续正式训练项目相同。请设计一个程序找出并返回第一个正式训练项目编号。如果两个链表不存在相交节点，返回 null 。

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // ListNode* pa = headA;
        // ListNode* pb = headB;
        if(!headB || !headA){
            return NULL;
        }
        ListNode* cur =headA,*res = NULL;
        while(cur){
            cur->val *= -1;
            cur = cur->next;
        }
        cur = headB;
        while(cur){
            if(cur->val < 0){
                res = cur;
                break;
            }
            cur = cur->next;
        }
        cur = headA;
        while(cur){
            cur->val *= -1;
            cur = cur->next;
        }
        return res;
    }
};

  • 在这里插入图片描述

  • /**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(!headA || !headB){
            return nullptr;
        }
        ListNode *pa=headA,*pb=headB;
        while(pa != pb){
            pa = pa==nullptr?headB:pa->next;
            pb = pb==nullptr?headA:pb->next;
        }
        return pa;
    }
};

题目：请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

  • 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

  • /*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==nullptr){
            return nullptr;
        }
        for(Node* node = head;node!=nullptr;node=node->next->next){
            Node* newnode = new Node(node->val);
            newnode->next = node ->next;
            node->next = newnode;
        }
        for(Node* node =head;node!=nullptr;node = node->next->next){
            Node* newnode = node->next;
            newnode->random = (node->random != nullptr)?node->random->next:nullptr;
        }
        Node* newhead = head->next;
        for(Node* node=head;node!=nullptr;node = node->next){
            Node* newnode = node->next;
            node->next = node->next->next;
            newnode->next = (newnode->next!=nullptr)?newnode->next->next:nullptr;
        }
        return newhead;        
    }
};

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

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

相关文章

BUUCTF [MRCTF2020]ezmisc 1

BUUCTF [MRCTF2020]ezmisc 1

BUUCTF:https://buuoj.cn/challenges 题目描述&#xff1a; 得到的 flag 请包上 flag{} 提交。 感谢Galaxy师傅供题。 密文&#xff1a; 下载附件&#xff0c;解压得到.png图片。 从这里也可以看出图片经过修改&#xff0c;无法正常显示。 解题思路&#xff1a; 1、在010 E…
阅读更多...
【从浅识到熟知Linux】基本指定之find、grep、head和tail

【从浅识到熟知Linux】基本指定之find、grep、head和tail

&#x1f388;归属专栏&#xff1a;从浅学到熟知Linux &#x1f697;个人主页&#xff1a;Jammingpro &#x1f41f;每日一句&#xff1a;一篇又一篇&#xff0c;学写越上头。 文章前言&#xff1a;本文介绍find、grep、head和tail指令用法并给出示例和截图。 文章目录 find基本…
阅读更多...
华为ospf路由协议防环和次优路径中一些难点问题分析

华为ospf路由协议防环和次优路径中一些难点问题分析

第一种情况是ar3的/0/0/2口和ar4的0/0/2口发布在区域1时&#xff0c;当ar1连接ar2的线断了以后&#xff0c;骨干区域就断了&#xff0c;1.1.1.1到2.2.2.2就断了&#xff0c;ping不通了。但ar5和ar6可以ping通2.2.2.2和1.1.1.1&#xff0c;ar3和ar4不可以ping通2.2.2.2和1.1.1.1…
阅读更多...
分布式锁，分布式锁应该具备哪些条件，分布式锁的实现方式有：基于Zookeeper实现、Redis实现、数据库实现

分布式锁，分布式锁应该具备哪些条件，分布式锁的实现方式有：基于Zookeeper实现、Redis实现、数据库实现

文章目录 分布式锁0-1分布式锁--包含CAP理论模型概述分布式锁&#xff1a;分布式锁应该具备哪些条件&#xff1a;分布式锁的业务场景&#xff1a; 分布式锁的实现方式有&#xff1a;基于Zookeeper - 分布式锁实现思想优缺点基于Redis - 分布式锁实现思想实现思想的具体步骤&…
阅读更多...
新版画中画documentPictureInPicture API使用

新版画中画documentPictureInPicture API使用

关于该API&#xff0c;chrome dev有一篇比较好入门的文章&#xff0c;如果你没看过强烈推荐你先看这篇基础用法&#xff0c;该文章只针对API的特性和chrome dev文章进行扩展性说明。 提前说明&#xff0c;目前该API是非w3c草案功能&#xff0c;从chrome 116开始已经强推到stabl…
阅读更多...
计算机网络四大地址转换（IP,MAC、端口、域名）

计算机网络四大地址转换（IP,MAC、端口、域名）

计算机网络有四大地址&#xff0c;分别是 ip地址、 MAC地址、域名、端口 计算机网络地址 他们之间是如何转换&#xff0c;通过什么协议转换的 IP地址到MAC地址&#xff0c;通过ARP协议 MAC地址得到IP地址&#xff0c;通过RARP协议 通过域名的到IP地址 是通过DNS查询 端口是…
阅读更多...
Clion在Windows下build时出现undefined reference，即使cmake已经正确链接第三方库（如protobuf）？

Clion在Windows下build时出现undefined reference，即使cmake已经正确链接第三方库（如protobuf）？

你是否正在使用clion自带的vcpkg来安装了protobuf&#xff1f; 或者你是否自己使用visual studio自己编译了libprotobuf.lib&#xff1f; 你是否已经正确在CmakeLists.txt中添加了以下命令&#xff1a; find_package(Protobuf CONFIG REQUIRED) include_directories(${Protobu…
阅读更多...
硬盘上不小心删除了重要文档？试试这6个成功率高的数据恢复工具!

硬盘上不小心删除了重要文档？试试这6个成功率高的数据恢复工具!

您是否不小心重新格式化了存储卡或删除了想要保留的照片&#xff1f;最好的照片恢复软件可以提供帮助&#xff01;如果您使用数码相机拍摄的时间足够长&#xff0c;那么当您错误地删除了想要保留的图像、重新格式化了错误的 SD 卡&#xff0c;或者发现您的珍贵照片由于某种莫名…
阅读更多...
STM32-SPI1控制AD7705（Sigma-Delta-ADC芯片）

STM32-SPI1控制AD7705（Sigma-Delta-ADC芯片）

STM32-SPI1控制AD7705&#xff08;Sigma-Delta-ADC芯片&#xff09; 原理图手册说明功能方框图引脚功能 片内寄存器通信寄存器&#xff08;RS2、RS1、RS00、0、0&#xff09;设置寄存器时钟寄存器数据寄存器&#xff08;RS2、RS1、RS00、1、1&#xff09;测试寄存器&#xff08…
阅读更多...
EEG 脑电信号处理合集（2）： 信号预处理

EEG 脑电信号处理合集（2）： 信号预处理

脑电信号在采集完以后&#xff0c;需要进行一系列的预处理操作&#xff0c;然后才能用于后续的科学研究和计算。预处理是脑电信号分析最基本且重要的一步。基于python环境MNE库。 1 使用带通滤波器&#xff0c;信号滤波&#xff0c;去噪&#xff0c;去工频干扰 data_path sam…
阅读更多...
PyQt6运行QTDesigner生成的ui文件程序

PyQt6运行QTDesigner生成的ui文件程序

2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~_哔哩哔哩_bilibili2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~共计18条视频&#xff0c;包括&#xff1a;2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~、第2讲 PyQt6库和工具库Q…
阅读更多...
广州华锐互动：AR可视化展示昆虫让教学过程更直观生动

广州华锐互动：AR可视化展示昆虫让教学过程更直观生动

随着科技的不断发展&#xff0c;AR&#xff08;增强现实&#xff09;技术已经逐渐走进我们的生活。通过AR技术&#xff0c;我们可以将虚拟的信息叠加到现实世界中&#xff0c;让现实世界变得更加丰富多彩。在这篇文章中&#xff0c;我们将以昆虫为主题&#xff0c;探讨AR增强现…
阅读更多...
人工智能教程（二）：人工智能的历史以及再探矩阵

人工智能教程（二）：人工智能的历史以及再探矩阵

目录 前言 更多矩阵的知识 Pandas 矩阵的秩 前言 在上一章中&#xff0c;我们讨论了人工智能、机器学习、深度学习、数据科学等领域的关联和区别。我们还就整个系列将使用的编程语言、工具等做出了一些艰难的选择。最后&#xff0c;我们还介绍了一点矩阵的知识。在本文中&am…
阅读更多...
【教3妹学编程-算法题】二叉树中的伪回文路径

【教3妹学编程-算法题】二叉树中的伪回文路径

3妹&#xff1a;好冷啊&#xff0c; 冻得瑟瑟发抖啦 2哥 : 又一波寒潮来袭&#xff0c; 外面风吹的呼呼的。 3妹&#xff1a;今天还有雨&#xff0c;2哥上班记得带伞。 2哥 : 好的 3妹&#xff1a;哼&#xff0c;不喜欢冬天&#xff0c;也不喜欢下雨天&#xff0c;要是我会咒语…
阅读更多...
BUUCTF [ACTF新生赛2020]base64隐写 1

BUUCTF [ACTF新生赛2020]base64隐写 1

BUUCTF:https://buuoj.cn/challenges 题目描述&#xff1a; 得到的 flag 请包上 flag{} 提交。 密文&#xff1a; 下载附件&#xff0c;解压得到.zip文件&#xff0c;再次解压得到两个文件。 解题思路&#xff1a; 1、打开ComeOn!.txt文件&#xff0c;发现一大串经过Base64加…
阅读更多...
软著项目推荐 深度学习 python opencv 火焰检测识别 火灾检测

软著项目推荐 深度学习 python opencv 火焰检测识别 火灾检测

文章目录 0 前言1 基于YOLO的火焰检测与识别2 课题背景3 卷积神经网络3.1 卷积层3.2 池化层3.3 激活函数&#xff1a;3.4 全连接层3.5 使用tensorflow中keras模块实现卷积神经网络 4 YOLOV54.1 网络架构图4.2 输入端4.3 基准网络4.4 Neck网络4.5 Head输出层 5 数据集准备5.1 数…
阅读更多...
运动蓝牙耳机什么牌子好？百元蓝牙运动耳机排行榜

运动蓝牙耳机什么牌子好？百元蓝牙运动耳机排行榜

​跑步、骑车、健身等运动时&#xff0c;大家都需要一款专业的运动耳机来陪伴&#xff0c;它不仅可以提供高品质的音乐和佩戴舒适度&#xff0c;还可以帮助你掌握运动状态&#xff0c;让你更加专注和投入。今天我为大家推荐几款备受好评的运动耳机&#xff0c;它们都拥有不错的…
阅读更多...
常用的Linux的指令

常用的Linux的指令

目录 常用指令 1、文件和目录操作&#xff1a; 2、文件查看和编辑 3、系统信息 4、进程管理 5、用户和权限 6、网络操作 7、压缩和解压 8、软件包管理 常用指令 1、文件和目录操作&#xff1a; ls&#xff1a;列出目录内容 cd&#xff1a; 切换目录 pwd&#xff1a;显…
阅读更多...
模块的学习

模块的学习

模块合包的基本概念&#xff1a; 模块&#xff08;module&#xff09;&#xff1a;在python中&#xff0c;xx.py文件&#xff0c;就可以被看作模块 包&#xff08;package&#xff09;: 用来管理和存放模块的文件夹&#xff0c;就被称为包&…
阅读更多...
系列十四、BeanFactory vs FactoryBean

系列十四、BeanFactory vs FactoryBean

一、BeanFactory IOC思想是基于IOC容器完成的&#xff0c;IOC容器的底层就是对象工厂&#xff0c;其核心接口为BeanFactory&#xff0c;BeanFactory是一个工厂类&#xff0c;负责生产和管理各种各样的bean&#xff0c;也是Spring内部的使用接口&#xff0c;不提供给开发人员使用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023