C++算法题 - 链表

news2024/11/27 8:41:06

目录

  • 141. 环形链表
  • 2. 两数相加
  • 21. 合并两个有序链表
  • 138. 随机链表复制
  • 92. 反转链表Ⅱ
  • 25. K个一组翻转链表
  • 19. 删除链表的倒数第N个结点
  • 82. 删除排序链表中的重复元素Ⅱ
  • 61. 旋转链表
  • 86. 分隔链表
  • 146. LRU缓存

141. 环形链表

LeetCode_link

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：
在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
在这里插入图片描述
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：
链表中节点的数目范围是 [0, 10^4]
-10^5 <= Node.val <= 10^5
pos 为 -1 或者链表中的一个 有效索引 。

思路：一个指针的前进为1格，一个为两格，如果两格追上了一个格，就是有环；否则就是没有。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* l1 = head;
        ListNode* l2 = head;
        while(l2 != NULL && l2->next != NULL){
            l1 = l1->next;
            l2 = l2->next->next;
            if(l1 == l2)    return true;
        }
        return false;
        
    }
};

2. 两数相加

LeetCode_link

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：
在这里插入图片描述
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

思路：答案返回的是新链表

/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *n1 = l1;
        ListNode *n2 = l2;
        ListNode *head = new ListNode(1, nullptr);
        ListNode *run = head;
        int c = 0;
        while(n1 != nullptr && n2 != nullptr){
            ListNode *t = new ListNode((n1->val + n2->val + c) % 10, nullptr);
            run->next = t;
            run = run->next;
            c = (n1->val + n2->val + c) / 10;
            n1 = n1->next;
            n2 = n2->next;
        }
        while(n1 != nullptr){
            ListNode *t = new ListNode((n1->val + c) % 10, nullptr);
            run->next = t;
            run = t;
            c = (n1->val + c) / 10;
            n1 = n1->next;
        }
        while(n2 != nullptr){
            ListNode *t = new ListNode((n2->val + c) % 10, nullptr);
            run->next = t;
            run = t;
            c = (n2->val + c) / 10;
            n2 = n2->next;
        }
        if(c == 1){
            ListNode *t = new ListNode(1, nullptr);
            run->next = t;
        }
        return head->next;
    }
};

21. 合并两个有序链表

LeetCode_link

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：
在这里插入图片描述
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：
输入：l1 = [], l2 = []
输出：[]

示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode *head = new ListNode();
        ListNode *end = head;
        while(list1 != nullptr && list2 != nullptr){
            if(list1->val <= list2->val){
                end->next = list1;
                list1 = list1->next;
            }else{
                end->next = list2;
                list2 = list2->next;
            }
            end = end->next;
        }
        if(list1 != nullptr){
            end -> next = list1;
        }
        if(list2 != nullptr){
            end -> next = list2;
        }
        return head->next;
    }
};

138. 随机链表复制

LeetCode_link

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

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

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

  • val：一个表示 Node.val 的整数。
  • random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

你的代码 只 接受原链表的头节点 head 作为传入参数。

示例 1：
在这里插入图片描述
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：
在这里插入图片描述
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：
在这里插入图片描述
输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

提示：
0 <= n <= 1000
-10^4 <= Node.val <= 10^4
Node.random 为 null 或指向链表中的节点。

思路：用哈希表在给随机指针赋值的时候快速找到老节点对应的新节点。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
private:
    unordered_map<Node*, Node*> hash;
public:
    Node* copyRandomList(Node* head) {
        Node *n1 = head;
        Node *creat = new Node(0);
        Node *n2 = creat;
        while(n1 != NULL){
            Node *temp = new Node(n1->val);
            n2->next = temp;
            hash[n1] = temp;
            n2 = n2->next;
            n1 = n1->next;
        }
        n2->next = NULL;
        n2 = creat->next;
        n1 = head;
        while(n1 != NULL){
            n2->random = hash[n1->random];
            n1 = n1->next;
            n2 = n2->next;
        }
        return creat->next;
    }
};

92. 反转链表Ⅱ

LeetCode_link

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

示例 2：
输入：head = [5], left = 1, right = 1
输出：[5]

提示：
链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= 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:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        int count = 1;
        ListNode *n = head;
        ListNode *end, *start, *left_pre;
        while(count <= right){
            if(left > 1 && count == left - 1){
                left_pre = n;
            }else if(count == left){
                ListNode *temp = new ListNode(n->val, nullptr);
                start = temp;
                end = temp;
            }else if(count > left){
                ListNode *temp = new ListNode(n->val, start);
                start = temp;
            }
            n = n->next;
            count ++;
        }
        if(left == 1){
            head = start;
        }else{
            left_pre->next = start;
        }
        end->next = n;
        return head;

    }
};

25. K个一组翻转链表

LeetCode_link

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：
在这里插入图片描述
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

提示：
链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000

思路：
在这里插入图片描述

/**
 * 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* reverseKGroup(ListNode* head, int k) {
        ListNode *pre = nullptr, *right = head, *first;
        ListNode *start = nullptr, *end = nullptr;
        while(right != nullptr){
            vector<ListNode*> rec = reverse(right, k);
            start = rec[0], end = rec[1], right = rec[2];
            if(start == nullptr && end == nullptr)  break;
            if(pre == nullptr){
                head = start;
                pre = end;
            }else{
                pre->next = start;
                pre = end;
            }
            first = right;
        }
        pre->next = first;
        return head;

    }
    vector<ListNode*> reverse(ListNode* right, int k){
        if(right == nullptr)    return {nullptr, nullptr, nullptr};
        ListNode *start, *end;
        for(int i = 0; i < k; i++){
            ListNode *temp = new ListNode(right->val);
            if(i == 0){
                end = temp;
                start = temp;
            }else{
                temp -> next = start;
                start = temp;
            }
            right = right -> next;
            if(right == nullptr && i < k-1)    return{nullptr,nullptr,right};
        }
        return {start, end, right};
    }
};

19. 删除链表的倒数第N个结点

LeetCode_link

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：
输入：head = [1], n = 1
输出：[]

示例 3：
输入：head = [1,2], n = 1
输出：[1]

提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

思路：让一个指针先走K步，然后前指针后指针同时往后走，当前指针走到结尾了，后指针就指向了应该删除的位置。

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        ListNode *front = head, *back = head, *pre = head;
        while(n > 1){
            front = front->next;
            if(front == nullptr)    return nullptr;
            n--;
        }
        if(front->next == nullptr){
            head = head->next;
            return head;
        }
        while(front->next!=nullptr){
            if(back != head)    pre = pre->next;
            front = front->next;
            back = back->next;
        }
        pre->next = back->next;
        return head;
    }
};

82. 删除排序链表中的重复元素Ⅱ

LeetCode_link

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]

示例 2：
在这里插入图片描述
输入：head = [1,1,1,2,3]
输出：[2,3]

提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列

思路：

/**
 * 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* deleteDuplicates(ListNode* head) {
        if(head == nullptr) return nullptr;
        ListNode *start = head, *end = head ,*pre = head;
        int num = head->val;
        while(end->next != nullptr){
            while(end->next != nullptr && end->next->val == num){
                end = end->next;
            }
            if(start == end){
                pre = end;
            }else{
                if(start == head){
                    head = end->next;
                }else{
                    pre->next = end->next;
                }
            }
            if(end->next != nullptr){
                start = end->next;
                end = end->next;
                num = start->val;
            }
        }
        return head;
    }
};

61. 旋转链表

LeetCode_link

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

示例 2：
输入：head = [0,1,2], k = 4
输出：[2,0,1]

提示：
链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 10^9

思路：1、统计链表的长度；2、计算需要移动的位置，按照链表长度取余；3、用前后指针指向前半部分的尾和后半部分的尾，back指针和front指针分别指向图中位置；4、断开重新连接
在这里插入图片描述

/**
 * 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* rotateRight(ListNode* head, int k) {
        if(head == nullptr) return nullptr;
        ListNode *front = head, *back = head;
        int n = 0;
        //统计链表的长度
        while(front != nullptr){
            n++;
            front = front->next;
        }
        //计算需要移动的位置，按照链表长度取余
        n = k % n;
        //用前后指针指向前半部分的尾和后半部分的尾
        front = head;
        while(n--){
            front = front->next;
        }
        while(front->next != nullptr){
            front = front->next;
            back = back->next;
        }
        //重新连接
        front->next = head;
        head = back->next;
        back->next = nullptr;
        return head;
    }
};

86. 分隔链表

LeetCode_link

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当 保留 两个分区中每个节点的初始相对位置。

示例 1：
在这里插入图片描述
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

示例 2：
输入：head = [2,1], x = 2
输出：[1,2]

提示：
链表中节点的数目在范围 [0, 200] 内
-100 <= Node.val <= 100
-200 <= x <= 200

思路：把链表拆成两个链表，一个放小于的，一个放大于等于的，因为要保持相对位置，所以需要尾插法，最后再连上即可。

/**
 * 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* partition(ListNode* head, int x) {
        ListNode *head1 = new ListNode(), *end1 = head1;
        ListNode *head2 = new ListNode(), *end2 = head2;
        while(head != nullptr){
            if(head->val < x){
                end1->next = head;
                head = head->next;
                end1 = end1->next;
                end1->next = nullptr;
            }else{
                end2->next = head;
                head = head->next;
                end2 = end2->next;
                end2->next = nullptr;
            }
        }
        end1->next = head2->next;
        return head1->next;
    }
};

146. LRU缓存

LeetCode_link

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：

  • LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
  • int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
  • void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
    函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示：
1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 10^5
最多调用 2 * 10^5 次 get 和 put

思路：双向链表+哈希表，头节点value存放剩余缓存数量。

class LRUCache {
public:
    struct ListNode {
        int key;
        int value;
        ListNode *next, *last;
        ListNode(int k, int v,ListNode* l, ListNode* n) :  key(k), value(v), last(l), next(n) {}
    };
    ListNode *head, *tail;
    unordered_map<int, ListNode*> hash; // key, node

    LRUCache(int capacity) {
        head = new ListNode(-1, capacity, nullptr, nullptr);
        tail = new ListNode(-1,-1, nullptr, nullptr);
        head->next = tail;
        tail->last = head;
    }
    
    int get(int key) {
        if(hash.find(key) == hash.end()){
            return -1;
        }else{
            //找到le
            ListNode *n = hash[key];
            if(n->next == tail){
                return n->value;
            }else{
                remove(n);
                insert_tail(n);
                return n->value;
            }
        }
        return -1;
    }
    
    void put(int key, int value) {
        if(hash.find(key) == hash.end()){
            //没找到
            if(head->value > 0){
                //还有余量，直接插入就行
                ListNode *temp = new ListNode(key, value, nullptr, nullptr);
                hash[key] = temp;
                insert_tail(temp);
                head->value--;
            }else{
                //没有余量了
                int last_key = head->next->key;
                remove(head->next);
                hash.erase(last_key);
                ListNode *temp = new ListNode(key, value, nullptr, nullptr);
                hash[key] = temp;
                insert_tail(temp);
            }
        }else{
            //找到了
            ListNode *n = hash[key];
            if(n->next == tail){
                n->value = value;
            }else{
                remove(n);
                insert_tail(n);
                n->value = value;
            }
        }
    }
    void remove(ListNode* n){
        n->last->next = n->next;
        n->next->last = n->last;
    }
    void insert_tail(ListNode* n){
        n->last = tail->last;
        tail->last->next = n;
        tail->last = n;
        n->next = tail;
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

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

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

相关文章

TCP/IP协议（二）

TCP/IP协议（二）

一、TCP-选项 1.简介 在TCP/IP报文中&#xff0c;固定头部下边就是 "选项"部分。 (1)TCP头部的选项部分是TCP为了适应复杂的网络环境和更好的服务应用层而进行设计的 (2)大多数的TCP选项部分出现在TCP连接建立阶段 2.构成 2.1 最大报文传输段 最大报文传输段(Ma…
阅读更多...
代码随想录训练营Day 33|Python|Leetcode|● 理论基础 ● 509. 斐波那契数 ● 70. 爬楼梯 ● 746. 使用最小花费爬楼梯

代码随想录训练营Day 33|Python|Leetcode|● 理论基础 ● 509. 斐波那契数 ● 70. 爬楼梯 ● 746. 使用最小花费爬楼梯

理论基础 动态规划五步曲 确定dp数组&#xff08;dp table&#xff09;以及下标的含义确定递推公式dp数组如何初始化确定遍历顺序举例推导dp数组 509. 斐波那契数 斐波那契数 &#xff08;通常用 F(n) 表示&#xff09;形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始…
阅读更多...
c++11详解

c++11详解

目录 1.列表初始化 2.声明 3.右值引用和移动语句 4. c11新的类功能 5. 可变参数模板 6.lambda表达式 7.包装器 8. 后言 1. 列表初始化 1.1 {}的初始化 (1) c98标准规定可以使用{}对数组以及结构体进行统一的列表初始化. struct Point {int _x;int _y; };int main() {in…
阅读更多...
Kubernetes：云原生时代的核心引擎

Kubernetes：云原生时代的核心引擎

文章目录 一、Kubernetes简介&#xff1a;引领云原生潮流二、K8s的核心特性&#xff1a;自动化与智能化三、K8s的实践应用&#xff1a;打造高效云原生应用架构四、K8s的挑战与应对&#xff1a;安全与性能并重五、K8s的未来展望&#xff1a;无限可能与挑战并存《Kubernetes快速进…
阅读更多...
YOLOv8-pose针对视频实时提取打印对应关节点序号及坐标

YOLOv8-pose针对视频实时提取打印对应关节点序号及坐标

因为我在找如何提取YOLOv8-pose的关键点的时候&#xff0c;大多都是针对静态图像&#xff0c;视频直接套用不太行&#xff0c;因此就改进了一下&#xff0c;如下&#xff1a; 初步代码&#xff1a; import torch # 导入PyTorch库 import cv2 as cv # 导入OpenCV库并重命名为…
阅读更多...
上位机图像处理和嵌入式模块部署（树莓派4b进行自动化测试）

上位机图像处理和嵌入式模块部署（树莓派4b进行自动化测试）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 硬件、软件功能开发ok只是产品开发的第一步。怎么做到自动化测试、保证产品质量才是关键。很多时候&#xff0c;我们给客户提供了功能&#xff0c;…
阅读更多...
Rust HTTP 客户端：易于使用、功能强大 | 开源日报 No.228

Rust HTTP 客户端：易于使用、功能强大 | 开源日报 No.228

seanmonstar/reqwest Stars: 8.9k License: Apache-2.0 reqwest 是一个易于使用且功能强大的 Rust HTTP 客户端。 异步和阻塞客户端支持普通数据、JSON、urlencoded 和 multipart 数据格式可定制的重定向策略支持 HTTP 代理和系统原生 TLS 或 rustls 的 HTTPSCookie 存储功能…
阅读更多...
一、路由基础

一、路由基础

1.路由协议的优先级 路由器分别定义了外部优先级和内部优先级&#xff08;越小越优&#xff09; 路由选择顺序&#xff1a;外部优先级>>内部优先级&#xff08;相同时&#xff09; ①外部优先级&#xff1a;用户可以手工为各路由协议配置的优先级 ②内部优先级&#xf…
阅读更多...
Nuxt3 实战 (五)：Header 头部布局

Nuxt3 实战 (五)：Header 头部布局

前言 这两周一直忙公司系统的迭代需求&#xff0c;没啥时间捣鼓自己的小项目&#xff0c;趁着项目进入测试收尾阶段&#xff0c;抽空把 Layout 布局的 Header 部分先搞好。 需求拆分 顶部左侧放 Logo&#xff0c;右边放社交图标&#xff0c;暗黑模式切换提前准备好 Logo 和网…
阅读更多...
Centos8操作系统安装mysql5.7版本以及报错解决

Centos8操作系统安装mysql5.7版本以及报错解决

目录 一、卸载MySql 1.首先查看已安装的mysql 2.逐个或者执行一下命令统一卸载掉 注意&#xff1a; 3. 卸载其他相关文件 二、安装MySql 1.安装mysql的rpm源 2.安装MySql 如果遇到以下错误&#xff1a; 问题一: 解决方法&#xff1a; 问题二、 解决方法&#xff1…
阅读更多...
【一刷《剑指Offer》】面试题 9：斐波那契数列（扩展：青蛙跳台阶、矩阵覆盖）

【一刷《剑指Offer》】面试题 9：斐波那契数列（扩展：青蛙跳台阶、矩阵覆盖）

力扣对应链接&#xff1a;LCR 126. 斐波那契数 - 力扣&#xff08;LeetCode&#xff09; 牛客对应链接&#xff1a;斐波那契数列_牛客题霸_牛客网 (nowcoder.com) 核心考点&#xff1a;空间复杂度&#xff0c;fib 理解&#xff0c;剪枝重复计算。 一、《剑指Offer》内容 二、分…
阅读更多...
Linux多进程(二)进程通信方式三 共享内存

Linux多进程(二)进程通信方式三 共享内存

共享内存提供了一个在多个进程间共享数据的方式&#xff0c;它们可以直接访问同一块内存区域&#xff0c;因此比使用管道或消息队列等通信机制更高效。在多进程程序中&#xff0c;共享内存通常与信号量一起使用&#xff0c;以确保对共享内存的访问是线程安全的。 一、打开/创建…
阅读更多...
俊杰测评：电视盒子什么牌子好？电视盒子品牌排行榜

俊杰测评：电视盒子什么牌子好？电视盒子品牌排行榜

欢迎各位来到俊杰的数码测评频道&#xff0c;每年我会进行数十次电视盒子测评&#xff0c;今年已经买过二十多款电视盒子了&#xff0c;本期的测评主题是电视盒子什么牌子好&#xff0c;通过十天的深入详细对比后我整理了电视盒子品牌排行榜&#xff0c;近期想买电视盒子的可以…
阅读更多...
代码随想录算法训练营第五十一天| 309.最佳买卖股票时机含冷冻期，714.买卖股票的最佳时机含手续费，总结

代码随想录算法训练营第五十一天| 309.最佳买卖股票时机含冷冻期，714.买卖股票的最佳时机含手续费，总结

题目与题解 参考资料&#xff1a;买卖股票总结 309.最佳买卖股票时机含冷冻期 题目链接&#xff1a;309.最佳买卖股票时机含冷冻期 代码随想录题解&#xff1a;309.最佳买卖股票时机含冷冻期 视频讲解&#xff1a;动态规划来决定最佳时机&#xff0c;这次有冷冻期&#xff01;|…
阅读更多...
python获取文件路径

python获取文件路径

文件&#xff1a;allpath_parameter.py # 获取当前目录路径 # current_dir os.getcwd() # 获取当前目录路径 realpath00 os.path.abspath(os.path.join(os.path.dirname(os.path.split(os.path.realpath(__file__))[0]), .)) print(realpath00)# 获取当前目录的上级目录路…
阅读更多...
Centos安装/更新Docker

Centos安装/更新Docker

首先要配置好Centos 配置好静态IP 替换yum源为阿里云 Docker是什么&#xff1f; Docker 是一种开源的应用容器引擎&#xff0c;让开发者可以打包他们的应用以及依赖包到一个可移植的容器中&#xff0c;然后部署到任何流行的 Linux 机器上。是一种虚拟化的技术&#xff0c;可以把…
阅读更多...
linux 编译opencv遇到问题

linux 编译opencv遇到问题

linux编译opencv4.8的时候遇到问题 Error: suffix or operands invalid for vpand看到很多说法是升级as这个工具的版本&#xff0c;自测是从2.20升级到2.27就可以了
阅读更多...
12G-SDI视频分配器JR104D-4K-SDI

12G-SDI视频分配器JR104D-4K-SDI

JR104D-4K-SDI 12G-SDI分配器1分4,12G-SDI分配器1分2,12G-SDI分配器1分8,机架式12G-SDI分配器1分4&#xff0c;12G-SDI分配器4组1分4&#xff0c;12G-SDI分配器16组1分4&#xff0c; 广播级指标生产厂家。 一、产品介绍&#xff1a; JR104D-4K-SDI视频分配器&#xff0c;是按…
阅读更多...
Docker网络模式与cgroup资源控制

Docker网络模式与cgroup资源控制

前言 在 Docker 中&#xff0c;网络模式和 cgroup 资源控制作为关键功能&#xff0c;对于容器的性能优化和资源管理起着至关重要的作用。本文将介绍 Docker 的网络模式和cgroup资源控制&#xff0c;探讨不同网络模式的特点以及如何利用 cgroup 资源控制机制来有效管理容器的资…
阅读更多...
【SSM进阶学习系列丨整合篇】Spring+SpringMVC+MyBatis 框架配置详解

【SSM进阶学习系列丨整合篇】Spring+SpringMVC+MyBatis 框架配置详解

文章目录 一、环境准备1.1、创建数据库和表1.2、导入框架依赖的jar包1.3、修改Maven的编译版本1.4、完善Maven目录1.5、编写项目需要的包1.6、编写实体、Mapper、Service 二、配置MyBatis环境2.1、配置mybatis的主配置文件2.2、编写映射文件2.3、测试环境是否正确 三、配置Spri…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023