day1 链表专题 牛客TOP100 BM 1-10

news2024/11/25 21:22:26

文章目录

  • 链表
    • BM1 反转链表
    • BM2 链表内指定区间反转
    • BM3 链表中的节点每k个一组翻转
    • BM4 合并两个排序的链表
    • BM5 合并k个已排序的链表
    • BM6 判断链表中是否有环
    • BM7 链表中环的入口结点
    • BM8 链表中倒数最后k个结点
    • BM9 删除链表的倒数第n个节点
    • BM10 两个链表的第一个公共结点

链表

BM1 反转链表

题目
在这里插入图片描述

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* ReverseList(ListNode* head) {
        if(head == nullptr) return head;
        ListNode* cur = head;
        ListNode* pre = nullptr;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;//保存cur下一个节点
            cur->next = pre;//反转
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

BM2 链表内指定区间反转

在这里插入图片描述
自己写的时候，思路正确，但是处理不好反转后的拼接

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        ListNode* dummyhead = new ListNode(-1);
        dummyhead->next = head;

        //反转链表的前部分
        ListNode* start = dummyhead;
        for(int i=1; i<m; i++)
            start = start->next;//结点1
        cout << "start: "<< start->val <<endl;
        
        //反转链表的尾巴 第n个结点
        ListNode* right = start->next;
        for(int i=m; i<n; i++)
            right = right->next;//结点4
        cout << "right: "<< right->val <<endl;

        //反转链表的头尾
        ListNode* left = start->next;//2
        ListNode* end = right->next;//5
        
        //切断 left 1 2 3 4
        start->next = nullptr;
        right->next = nullptr;
        reverlist(left);

        //接回原来的链表
        start->next = right;//1->4
        left->next = end;//2->5
        return dummyhead->next;
    }
    void reverlist(ListNode* node)
    {
        ListNode* pre = nullptr;
        ListNode* cur = node;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
    }
};

写法2

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        ListNode* dummyhead = new ListNode(-1);
        dummyhead->next = head;

        //写法1
        /*//反转链表的前部分
        ListNode* start = dummyhead;
        for(int i=1; i<m; i++)
            start = start->next;//结点1
        cout << "start: "<< start->val <<endl;
        
        //反转链表的尾巴 第n个结点
        ListNode* right = start->next;
        for(int i=m; i<n; i++)
            right = right->next;//结点4
        cout << "right: "<< right->val <<endl;

        //反转链表的头尾
        ListNode* left = start->next;//2
        ListNode* end = right->next;//5
        
        //切断 left 1 2 3 4
        start->next = nullptr;
        right->next = nullptr;
        reverlist(left);

        //接回原来的链表
        start->next = right;//1->4
        left->next = end;//2->5
        return dummyhead->next;*/

        //写法2
        ListNode* pre = dummyhead;
        ListNode* cur = head;
        
        //找到结点m
        for(int i=1; i<m; i++)
        {
            pre = cur;//m-1
            cur = cur->next;//m
        }
        //从m到n反转 依次断掉指向后续的指针，反转指针方向
        ListNode* temp;
        for(int i=m; i<n; i++)
        {
            temp = cur->next;//要反转的结点
            cur->next = temp->next;//指向n
            temp->next = pre->next;//反转
            pre->next = temp;//指向m
        }
        return dummyhead->next;

    }
    void reverlist(ListNode* node)
    {
        ListNode* pre = nullptr;
        ListNode* cur = node;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
    }
};

BM3 链表中的节点每k个一组翻转

在这里插入图片描述
自己写的乱七八糟，看了解答之后觉得好聪明啊，关键是要找到反转前的局部链表的尾巴，这个也是要返回的链表头，然后建立每一组的连接！！

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        //每一组局部链表的表头 反转前局部链表的尾巴 
        ListNode* tail = head;
        //找到尾巴
        for(int i=0; i<k; i++)
        {
            //如果链表不够长 返回结果
            if(tail == nullptr) return head;
            tail = tail->next;
        }

        //反转局部链表
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* temp;
        //在到达当前段尾节点前
        while(cur != tail)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }

        //反转后链表尾部连接下一组表头
        head->next = reverseKGroup(tail, k);
        return pre;
    }
};

模拟的写法，将一条链表分为链表长度/k块链表，如果处不尽则说明后面会有剩下的那一块是不满长度为k的。
最初需要定义虚拟表头dummyhead（最终结果）和局部链表的反转前的表头start。然后遍历每一组局部链表，并反转。反转后需要将start与反转后的局部链表头pre连接（反转前局部链表的尾部），再更新下一组的局部链表的表头，也就是将start更新到最前。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k<=1) return head;
        if(head == nullptr) return nullptr;

        int len = getLength(head);
        int part = len / k;//分组

        ListNode* dummyhead = new ListNode(-1);
        ListNode* start = dummyhead;//每一组局部链表的表头
        for(int i=0; i<part; i++)
        {
            //局部链表反转后的尾巴
            ListNode* pre = nullptr;
            for(int j=0; j<k; j++)
            {
                ListNode* temp = head->next;
                head->next = pre;
                pre = head;
                head = temp;
            }
            start->next = pre;//链表头连接 反转后的局部链表 的表头
            while(start->next) start = start->next;//更新下一组的表头
        }
        start->next = head;
        return dummyhead->next;

    }
private:
    //获取链表长度
    int getLength(ListNode* node)
    {    
        int len = 0;
        if(node == nullptr) return len;
        while(node)
        {
            len++;
            node = node->next;
        }
        return len;
    }
};

BM4 合并两个排序的链表

在这里插入图片描述

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(!pHead1 && !pHead2) return nullptr;
        if(!pHead1) return pHead2;
        if(!pHead2) return pHead1;

        ListNode* dummyhead = new ListNode(-1);
        ListNode* cur = dummyhead;
        while(pHead1 && pHead2)
        {
            if(pHead1->val <= pHead2->val)
            {
                cur->next = pHead1;
                pHead1 = pHead1->next;//1->2
                //cout << "   cur:" << cur->next->val << "  pHead1:" << pHead1->val << endl;
            }
            else if(pHead1->val > pHead2->val)
            {
                cur->next = pHead2;
                pHead2 = pHead2->next;
                //cout << "   cur:" << cur->next->val << "  pHead2:" << pHead2->val << endl;
            }
            cur = cur->next;//连接新链表
        }
        //如果还有剩下的结点 单独处理最后一个结点
        cur->next = (pHead2 == nullptr) ? pHead1 : pHead2;
        return dummyhead->next;
    }
};

方法2，取较小的结点

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(!pHead1 && !pHead2) return nullptr;
        if(!pHead1) return pHead2;
        if(!pHead2) return pHead1;
        ListNode* dummyhead = new ListNode(-1);
        ListNode* cur = dummyhead;
        while(pHead1 && pHead2)
        {
            if(pHead1->val > pHead2->val) swap(pHead1, pHead2);
            cur->next = pHead1;//建立新连接
            pHead1 = pHead1->next;//更新
            cur = cur->next;//更新
        }
        cur->next = (pHead2 == nullptr) ? pHead1 : pHead2;
        return dummyhead->next;
    }
};

BM5 合并k个已排序的链表

在这里插入图片描述

这个写法会把负数的结点吞掉，例如输入：[{-5},{-9,-8,-7,-5,1,1,1,3},{-10,-7,-6,-6,-6,0,1,3,3},{-10,-8,-7,-2,3,3},{-1,4},{-5,-4,-1}]，输出是{-5,0,1,1,1,1,3,3,3,3,3,4}

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // write code here
        ListNode* dummyhead = new ListNode(-1);
        dummyhead->next = lists[0];
        ListNode* cur = dummyhead;
        for(int i=1; i<lists.size();)
        {
            cur->next = mergeList(lists[i], lists[i+1]);
            cur = cur->next;
            i += 2;
        }
        return dummyhead->next;
    }
    ListNode* mergeList(ListNode* head1, ListNode* head2)
    {
        if(head1 == nullptr) return head2;
        if(head2 == nullptr) return head1;
        ListNode* dummyhead =  new ListNode(0);
        ListNode* cur = dummyhead;
        while(head1 && head2)
        {
            if(head1->val >= head2->val) swap(head1, head2);
            cur->next = head1;
            head1 = head1->next;
            cur = cur->next;
        }
        cur->next = (head1 == nullptr) ? head2 : head1;
        return dummyhead->next;
    }

};

加入并归排序后的，可以输出负数结点了

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return divideMerge(lists, 0, lists.size()-1);
    }
    //划分合并区间函数
    ListNode* divideMerge(vector<ListNode *> &lists, int left, int right){
        if(left > right)
            return NULL;
        //中间一个的情况
        else if(left == right)
            return lists[left];
        //从中间分成两段，再将合并好的两段合并
        int mid = (left + right) / 2;
        return mergeList(divideMerge(lists, left, mid), divideMerge(lists, mid + 1, right));
    }
    ListNode* mergeList(ListNode* head1, ListNode* head2)
    {
        if(!head1 && !head2) return nullptr;
        if(head1 == nullptr) return head2;
        if(head2 == nullptr) return head1;
        ListNode* dummyhead =  new ListNode(0);
        ListNode* cur = dummyhead;
        while(head1 && head2)
        {
            if(head1->val >= head2->val) swap(head1, head2);
            cur->next = head1;
            head1 = head1->next;
            cur = cur->next;
        }
        cur->next = (head1 == nullptr) ? head2 : head1;
        return dummyhead->next;
    }

};

BM6 判断链表中是否有环

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

思路就是，快慢指针同时出发，慢指针走一步，快指针走两步。快指针肯定先进入环，慢指针后入环，如果两个指针相遇说明有环，如果没有相遇，遍历结束说明没有换。

第一次写的时候，有一组很长的链表没有通过，while循环内没有对fast的下一个结点进行判断，可能会一直在循环里边不终止。加了一个判断，如果fast有下一个结点才更新，否则也是说明链表走到头了。又或者是while的判断条件加上fast->next != null

/**
 * 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) {
        if(head == nullptr || head->next == nullptr) return false;
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast && slow)
        {
            slow = slow->next;
            //下面这个if-else是改正后的写法
            if(fast->next) fast = fast->next->next;
            else return false;
            if(fast == slow) return true;
        }
        return false;//如果fast先遇到null说明没有环
    }
};

BM7 链表中环的入口结点

在这里插入图片描述
上一题是判断有没有环，这个是有环然后要找到环入口。

思路，也是快慢指针。

  • 首先，快慢指针同时出发，慢指针走一步，快指针走两步。快指针肯定先进入环，慢指针后入环，如果两个指针相遇说明有环，如果没有相遇，遍历结束说明没有环。
  • 然后，第一次相遇时，在这个地方，重新定义两个指针，慢指针从头开始走，快指针在换里边走同时移动一步，如果相遇就找到了环入口，否则返回null。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        if(pHead == nullptr) return nullptr;
        ListNode* fast = pHead;
        ListNode* slow = pHead;
        while(fast!=nullptr && fast->next != nullptr)
        {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)
            {
                slow = pHead;
                ListNode* entrynode = fast;
                while(entrynode)
                {
                    //先判断 有可能就是一个闭环链表
                    if(entrynode == slow) return entrynode;
                    slow = slow->next;
                    entrynode = entrynode->next;
                }
            }
        }
        return nullptr;
    }
};

BM8 链表中倒数最后k个结点

在这里插入图片描述
思路-快慢指针：

  • 首先，快指针先走K步，在这里要注意两个特殊情况，一个是链表不够长，一个是正好需要返回倒数最后一个结点（第一个结点）。
  • 然后，慢指针从头开始，和快指针同时前进，快指针走到链表尾，慢指针走到第k个结点了。
/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 *  ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
  public:
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        //空链表
        if (pHead == nullptr) return pHead;
        ListNode* fast = pHead;
        while(k--)
        {
            if(fast->next == nullptr && k>0) return nullptr;//链表不够长
            if(fast->next == nullptr) return pHead;//倒数最后一个
            fast = fast->next;
            //cout << "  fast: " << fast->val;
        }
        while(fast)
        {
            pHead = pHead->next;
            fast = fast->next;
        }
        return pHead;
    }
};

BM9 删除链表的倒数第n个节点

在这里插入图片描述
思路在上一题的基础上，在保存一个倒数第K-1个节点，然后逻辑删除就可以了。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == nullptr) return head;
        ListNode* fast = head;
        while(n--)
        {
            if(fast->next==nullptr && n>0) return nullptr;
            if(fast->next==nullptr)
            {
                return head->next;//逻辑删除
            }
            cout << "  fast: " << fast->val;
            fast = fast->next;
        }
        ListNode* slow = head;
        ListNode* temp;
        while(fast)
        {
            temp = slow;//倒数第k-1个结点
            slow = slow->next;//倒数第k个结点
            fast = fast->next;
        }
        temp->next = slow->next;
        return head;
    }
};

BM10 两个链表的第一个公共结点

在这里插入图片描述
思路：统计长度，计算长度差len，长的链表先走len步，然后再和短链表一起走，如果两结点相同说明有公共结点。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        if(!pHead1 || !pHead2) return nullptr;
		int len1 = getLenofList(pHead1);
		int len2 = getLenofList(pHead2);
		if(len1 < len2)
		{
			swap(pHead1, pHead2);
			swap(len1, len2);	
		}
		int len = len1 - len2;
		while(len--)
		{
			pHead1 = pHead1->next;
		}
		//cout << pHead1->val<<endl;
		while(pHead1)
		{
			if(pHead1 == pHead2) return pHead1;
			pHead1 = pHead1->next;
			pHead2 = pHead2->next;
		}
		return nullptr;
    }
	int getLenofList(ListNode* head)
	{
		int res = 0;
		if(head == nullptr) return res;
		while(head)
		{
			res++;
			head = head->next;
		}
		return res;
	}
};

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

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

相关文章

ssm+vue绿色农产品推广应用网站源码和论文PPT

ssm+vue绿色农产品推广应用网站源码和论文PPT

ssmvue绿色农产品推广应用网站041 开发工具&#xff1a;idea 数据库mysql5.7 数据库链接工具&#xff1a;navcat,小海豚等 技术&#xff1a;ssm 摘 要 21世纪的今天&#xff0c;随着社会的不断发展与进步&#xff0c;人们对于信息科学化的认识&#xff0c;已由低层次向高…
阅读更多...
浅谈限流式保护器在电气线路火灾中的应用

浅谈限流式保护器在电气线路火灾中的应用

安科瑞 华楠 电气线路起火的主要原因 1.线路短路 所谓短路就是交流电路的两根导线互相触碰&#xff0c;电流不经过线路中的用电设备&#xff0c;而直接形成回路。由于电线本身的电阻比较小&#xff0c;若仅是通过电线这个回路&#xff0c;电流就会急剧变大&#xff0c;比正常情…
阅读更多...
HAProxy的配置与搭建

HAProxy的配置与搭建

Haproxy概念 HAProxy是可提供高可用性、负载均衡以及基于TCP和HTTP应用的代理&#xff0c;是免费、快速并且可靠的一种解决方案。HAProxy非常适用于并发大&#xff08;并发量达1w以上&#xff09;web站点&#xff0c;这些站点通常又需要会话保持或七层处理。HAProxy的运行模式…
阅读更多...
MySQL创建表报错

MySQL创建表报错

CREATE TABLE IF NOT EXISTS nhooo_b1 (nhooo_id INT UNSIGNED AUTO_INCREMENT,nhooo_title VARCHAR(100) NOT NULL,nhooo_author VARCHAR(40) NOT NULL,submission_date DATE,PRIMARY KEY (nhooo_id) ) ENGINEINNODB DEFAULT CHARSETutf8;创建表始终报以下错误&#xff1a; 这…
阅读更多...
Linux操作系统调度基本准则和实现

Linux操作系统调度基本准则和实现

今天分享一篇处理器调度相关的理论介绍文章。 1&#xff0c;基本概念 在多道程序系统中&#xff0c;进程的数量往往多于处理机的个数&#xff0c;进程争用处理机的情况就在所难免。处理机调度是对处理机进行分配&#xff0c;就是从就绪队列中&#xff0c;按照一定的算法&…
阅读更多...
k8s-ingress-context deadline exceeded

k8s-ingress-context deadline exceeded

报错&#xff1a; rancher-rke-01:~/rke # helm install rancher rancher-latest/rancher --namespace cattle-system --set hostnamewww.rancher.local Error: INSTALLATION FAILED: Internal error occurred: failed calling webhook "validate.nginx.ingress.kube…
阅读更多...
【使用Node.js搭建自己的HTTP服务器】

【使用Node.js搭建自己的HTTP服务器】

文章目录 前言1.安装Node.js环境2.创建node.js服务3. 访问node.js 服务4.内网穿透4.1 安装配置cpolar内网穿透4.2 创建隧道映射本地端口 5.固定公网地址 前言 Node.js 是能够在服务器端运行 JavaScript 的开放源代码、跨平台运行环境。Node.js 由 OpenJS Foundation&#xff0…
阅读更多...
二叉搜索树的(查找、插入、删除)

二叉搜索树的(查找、插入、删除)

一、二叉搜索树的概念 二叉搜索树又称二叉排序树&#xff0c;它或者是一棵空树&#xff0c;或者是具有以下性质的二叉树: 1、若它的左子树不为空&#xff0c;则左子树上所有节点的值都小于根节点的值&#xff1b; 2、若它的右子树不为空&#xff0c;则右子树上所有节点的值都…
阅读更多...
使用rook搭建Ceph集群

使用rook搭建Ceph集群

宿主机&#xff1a; MacBook Pro&#xff08;Apple M2 Max&#xff09; VMware Fusion Player 版本 13.0.2 VM软硬件&#xff1a; ubuntu 22.04.2 4核 CPU&#xff0c;5G 内存&#xff0c;40G硬盘 *每台机器分配硬件资源很重要&#xff0c;可以适当超过宿主机的资源量&am…
阅读更多...
张驰咨询：有效导入精益生产咨询，企业提升竞争力的关键

张驰咨询：有效导入精益生产咨询，企业提升竞争力的关键

精益生产是一种源于日本的先进生产管理理念&#xff0c;旨在通过消除生产过程中的浪费&#xff0c;提高生产效率和质量&#xff0c;降低成本&#xff0c;从而提升企业的竞争力。在我国&#xff0c;越来越多的企业开始尝试导入精益生产咨询&#xff0c;但效果并不尽如人意。为了…
阅读更多...
关于slot-scope已经废弃的问题

关于slot-scope已经废弃的问题

说起来啊&#xff0c;这个问题啊&#xff0c;我之前一直没关注&#xff0c;还是webstorm给我的警告。 因为使用了element-ui的组件库&#xff0c;所以在使用组件的时候往往就cv大法了&#xff0c;直到今天用webstorm写代码是&#xff0c;提示了如下的错误 我这一看&#xff0c…
阅读更多...
伦敦金短线好还是长线好

伦敦金短线好还是长线好

在伦敦金投之中&#xff0c;长期有一个争论很久的问题&#xff0c;那就是伦敦金投资究竟是长线好还是短线好&#xff1f;不同的投资者对这个问题有不同的看法&#xff0c;一般认为&#xff0c;伦敦金投资比较适合短线交易。笔者也将讨论这个问题&#xff0c;看看伦敦金投资是不…
阅读更多...
《网络是怎样连接的》（四）

《网络是怎样连接的》（四）

本文主要取材于 《网络是怎样连接的》 第四章。 目录 4.1 互联网的基本结构 4.2光纤接入网&#xff08;FTTH&#xff09; 4.3 接入网中使用的PPP和隧道 4.4 网络运营商的内部 4.5 跨越运营商的网络包 简述&#xff1a;本文主要内容是解释 网络包是如何通过互联网接入路由…
阅读更多...
svg mask和stroke冲突问题

svg mask和stroke冲突问题

目录 先说结论各种样例首先是水平、垂直的线然后是斜线如果是图形加stroke呢用《g》标签包起来呢 总结 先说结论 实际上svg里&#xff0c;mask对svg内元素起作用的并非元素本身&#xff0c;而是元素几何形状的外包矩形&#xff0c;特别是和stroke有冲突&#xff0c;会产生奇怪…
阅读更多...
opencv 进阶16-基于FAST特征和BRIEF描述符的ORB（图像匹配)

opencv 进阶16-基于FAST特征和BRIEF描述符的ORB（图像匹配)

在计算机视觉领域&#xff0c;从图像中提取和匹配特征的能力对于对象识别、图像拼接和相机定位等任务至关重要。实现这一目标的一种流行方法是 ORB&#xff08;Oriented FAST and Rotated Brief&#xff09;特征检测器和描述符。ORB 由 Ethan Rublee 等人开发&#xff0c;结合了…
阅读更多...
工作7年的测试员，明白了如何正确的“卷“

工作7年的测试员，明白了如何正确的“卷“

背景 近两年&#xff0c;出台和落地的反垄断法&#xff0c;明确指出要防止资本无序扩张。 这也就导致现在的各大互联网公司&#xff0c;不能再去染指其他已有的传统行业&#xff0c;只能专注自己目前存量的这些业务。或者通过技术创新&#xff0c;开辟出新的行业。 但创新这种…
阅读更多...
vmware 虚拟机开机自启动脚本

vmware 虚拟机开机自启动脚本

1、建立一个txt文件 D:\VMware\VMware Workstation\vmrun.exe -T ws start "I:\Documents\Virtual Machines\centos\centos.vmx" nogui 注意&#xff1a;如果路径中有中文需要先转换txt文件编码格式ANSI 2、设置bat开机自启动 winr shell:startup 复制文本文件到…
阅读更多...
【uniapp】微信小程序 ， 海报轮播图弹窗，点击海报保存到本地，长按海报图片分享，收藏或保存

【uniapp】微信小程序 ， 海报轮播图弹窗，点击海报保存到本地，长按海报图片分享，收藏或保存

uivew 2.0 uniapp 海报画板 DCloud 插件市场 第一步&#xff0c;下载插件并导入HbuilderX 第二步&#xff0c;文件内 引入 海报组件 <template><painter ref"haibaorefs"></painter> <template> <script>import painter from /comp…
阅读更多...
Docker关于下载，镜像配置，容器启动，停止，查看等基础操作

Docker关于下载，镜像配置，容器启动，停止，查看等基础操作

系列文章目录 文章目录 系列文章目录前言一、安装Docker并配置镜像加速器二、下载系统镜像&#xff08;Ubuntu、 centos&#xff09;三、基于下载的镜像创建两个容器 &#xff08;容器名一个为自己名字全拼&#xff0c;一个为首名字字母&#xff09;四、容器的启动、 停止及重启…
阅读更多...
汽车检测报告小程序开发制作方案

汽车检测报告小程序开发制作方案

传统的车辆检测流程通常繁琐且耗时&#xff0c;用户对更快速、便捷的检测方式有了更高的期望。基于这一需求&#xff0c;开发一款汽车检测报告小程序将成为现实生活中的实用工具。 产品定位为一款提供汽车检测报告查询的小程序&#xff0c;主要服务于需要进行汽车检测的车主、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023