递归专题训练详解（回溯，剪枝，深度优先）

news2024/11/24 15:34:36

1.汉诺塔问题

在经典汉诺塔问题中，有 3 根柱子及 N 个不同大小的穿孔圆盘，盘子可以滑入任意一根柱子。一开始，所有盘子自上而下按升序依次套在第一根柱子上(即每一个盘子只能放在更大的盘子上面)。移动圆盘时受到以下限制:
(1) 每次只能移动一个盘子;
(2) 盘子只能从柱子顶端滑出移到下一根柱子;
(3) 盘子只能叠在比它大的盘子上。

//确定子问题处理方式是相同的
//确定递归函数的函数头传参
//确定函数体也就子问题的处理方式
//判断函数出口

class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) {
        int n=A.size();
        dfs(A,B,C,n);
    }

    void dfs(vector<int>& A,vector<int>&B ,vector<int>& C,int n){
        if(n==1){
        C.push_back(A.back());//这里一定是要A.back(),可以画一下递归展开图
        A.pop_back();
        return;
        }//函数出口

        dfs(A,C,B,n-1);//不关心如何递归下去的，认为该函数一定能够帮我做到把a上的n-1数据借助c挪动b上

        C.push_back(A.back());//这里一定是要A.back(),可以画一下递归展开图
        A.pop_back();

        dfs(B,A,C,n-1);//同样认为该函数一定能把b上残留的n-1个数据借助a放到c上面
    }
};

2.合并升序链表

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

/**
 * 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* newHead=merge(list1,list2);
        return newHead;
    }

    ListNode* merge(ListNode* l1,ListNode* l2){
        if(l1==nullptr) return l2;
        if(l2==nullptr) return l1;


        if(l1->val<l2->val){
            l1->next=merge(l1->next,l2);
            return l1;//返回拼好的头节点
        }

        else{
            l2->next=merge(l2->next,l1);
            return l2;
        }

    }
};

3. 反转链表

/**
 * 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* reverseList(ListNode* head) {
        if(head==nullptr||head->next==nullptr)return head;
        ListNode* newhead=reverseList(head->next);//认为一定可以返回一个已经逆序的子链表
        head->next->next=head;//让已经逆序的子序列的头节点指向子序列的上一个头节点
        head->next=nullptr;
        return newhead;//这里newhead一直是没有移动过的，一直都是新的链表的头结点。
    }
};

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* swapPairs(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
        {
            return head;
        }

        ListNode* new_head=head->next;
        ListNode* tmp=head->next->next;//小心中途修改的问题
        head->next->next=head;
        head->next=swapPairs(tmp);
        return new_head;
    }
};

5. Pow（x,n）

  • -100.0 < x < 100.0
  • -2^31 <= n <= 2^31-1
  • -10^4 <= x^n <= 10^4

本题需要注意负数的情况和超int取值范围的情况

这样会语法报错。。。

class Solution {
public:
    double myPow(double x, int n) 
    {
        return n > 0 ?pow(x,n) : 1.0/pow(x,-(long long)n );
    }

    double pow(double x,long long n)
    {
        if(n==0) return 1.0;

        double ret=pow(x,n/2);

        if(n%2==0){return ret*ret;}
        else{return ret*ret*x;}
    }
};

6. 布尔逻辑二叉树

class Solution {
public:
    bool evaluateTree(TreeNode* root) {
        if(root->left==nullptr)
        {
            if(root->val==1)return true; 
            else return false;
        }

        bool left=evaluateTree(root->left);
        bool right=evaluateTree(root->right);
        if(root->val==2)
        {
            return left || right;
        }
        else 
        {
            return left && right;
        }

    }
};

7.根到叶子之和 

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

  • 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

//函数头设计，我们认为传入一个节点，那么就会算出此节点到所有节点的数字之和
//函数体：从上一层获得此前的所有数字组合再拼上此层，所以需要多设计一个参数来记录
//函数出口：当没有孩子的时候
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        return dfs(root,0);
    }

    int dfs(TreeNode* root,int presum)
    {
        // if(root==nullptr)
        // {
        //     return presum;题目给的一定是有一个节点
        // }

        presum=presum*10+root->val;
        std::cout<<presum<<std::endl;
        int ret=0;//因为函数的功能是用来计算之和并返回，所以不能直接presum传入，此处presum只是用于记录已经遍历了的数字。

        if(root->left==nullptr&&root->right==nullptr){
            return presum;
        }

        if(root->left) ret+=dfs(root->left,presum);
        if(root->right) ret+= dfs(root->right,presum);

        return ret;
    }
};

8.二叉树剪枝

给定一个二叉树 根节点 root ，树的每个节点的值要么是 0，要么是 1。请剪除该二叉树中所有节点的值为 0 的子树。

节点 node 的子树为 node 本身，以及所有 node 的后代。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
//函数体设计
//返回一个已经剪枝的根节点

//函数出口：当自己是空的时候返回空，处理动作一致

class Solution {
public:
    TreeNode* pruneTree(TreeNode* root) {
        // if(root==nullptr)
        // {
        //     return nullptr;
        // }

        if(root->left) root->left=pruneTree(root->left);
        if(root->right) root->right=pruneTree(root->right);

        if(root->left==nullptr&&root->right==nullptr&&root->val==0)
        //走到头才算是树枝当树枝被剪完了自己也就是树枝的。
        {
            //delete root;
            root=nullptr;
            // return nullptr;
        }

        return root;
    }
};

9.验证二叉搜索树（注意剪枝）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
long long prev_val=LONG_MIN;

    bool isValidBST(TreeNode* root) {
        if(root==nullptr)
        {
            return true;
        }
        bool left=isValidBST(root->left);

        if(left==false) return false;//剪枝
        
        bool cur=false;
        if(root->val>prev_val)
        {
            prev_val=root->val;
            cur=true;
        }

        if(right==false) return false;//剪枝

        bool right=isValidBST(root->right);
        //cout<< root->val;



        return left&&right&&cur;
    }
};

10. 二叉搜索树第k小的元素（二叉搜索树中序遍历是一个有序序列）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int count;
    int ret;

    int kthSmallest(TreeNode* root, int k) {
        count=k;
        return dfs(root);
    }

    int dfs(TreeNode* root)
    {
        if(root==nullptr){
            return ret;
        }
        ret=dfs(root->left);
        if(count==0)
        {
            return ret;
        }
        ret=root->val;
        count--;
        ret=dfs(root->right);

        return ret;
    }
};

11. 二叉树的所有路径

12. 全排列

1.此处path设置为全局变量更好，虽然回溯时需要修改，但是节省一些空间并且效率更高。：

class Solution {
public:

    vector<vector<int>> ret;
    vector<bool> check;//用于记录哪些数字使用过了而达到剪枝的效果，回溯的时候需要把使用过的数字还回去
    vector<int> path;//这里的path最好使用全局变量
    vector<vector<int>> permute(vector<int>& nums) {
        check.resize(nums.size());
        dfs(nums,path);
        return ret;
    }

    void dfs(vector<int>& nums,vector<int> path)
    {
        if(nums.size()==path.size())
        {
            ret.push_back(path);
            return ;
        }

        for(int i=0;i<nums.size();i++)
        {


            if(check[i]==true)
            {
                continue;
            }
            check[i]=true;
            vector<int> tmp=path;
            tmp.push_back(nums[i]);
            dfs(nums,tmp);

            check[i]=false;
        }
    }
};

2. 修改后：

class Solution {
public:

    vector<vector<int>> ret;
    vector<bool> check;//用于记录哪些数字使用过了而达到剪枝的效果，回溯的时候需要把使用过的数字还回去
    vector<int> path;//这里的path最好使用全局变量
    vector<vector<int>> permute(vector<int>& nums) {
        check.resize(nums.size());
        dfs(nums,path);
        return ret;
    }

    void dfs(vector<int>& nums,vector<int>& path)
    {
        if(nums.size()==path.size())
        {
            ret.push_back(path);
            return ;
        }

        for(int i=0;i<nums.size();i++)
        {


            if(check[i]==true)
            {
                continue;
            }
            check[i]=true;
            // vector<int> tmp=path;
            // tmp.push_back(nums[i]);
            path.push_back(nums[i]);
            dfs(nums,path);

            check[i]=false;//向下递归完后恢复现场
            path.pop_back();
        }
    }
};

13. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

13. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<string> ret;
    string path;
    int i=0;
    vector<string> binaryTreePaths(TreeNode* root) 
    {
        if(root==nullptr) return ret;//假设会传入空，最好不要写在dfs函数里面
        dfs(root,path);
        return ret;
    }

    void dfs(TreeNode* root,string path)
    {
        path+=to_string(root->val);
        if(root->left==nullptr&&root->right==nullptr)
        {
            ret.push_back(path);
            return;
        }
        path+="->";
        if(root->left) dfs(root->left,path);
        if(root->right) dfs(root->right,path);//剪枝，并且达到了不会传入空的效果

    }
};

14. 子集

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    //vector<bool> check;
    vector<vector<int>> subsets(vector<int>& nums) 
    {
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums ,int pos)
    {
        ret.push_back(path);

        for(int i=pos;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }

    }
};

15. 异或和按位或分清楚

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    int ret;//返回值总和

    int tmp=0;//记录当前层异或的值
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos)
    {
        ret+=tmp;
        for(int i=pos;i<nums.size();i++)
        {
            tmp^=nums[i];

            dfs(nums,i+1);

            tmp^=nums[i];
        }
    }
};

16. 全排列 ||

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    vector<vector<int>> ret;
    vector<bool> check;
    vector<int> path;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        check.resize(nums.size(),false);
        //没有上句会报错Line 84: Char 2: runtime error: store to null pointer of type 'std::_Bit_type' (aka 'unsigned long') (stl_bvector.h)
        dfs(nums);
        return ret;
    }

    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();i++)
        {


            if(check[i]==true ||( i!=0 && nums[i]==nums[i-1] && check[i-1] == false ))
            //check[i-1]==false;说明nums[i]和nums[i-1]同层进行判断比较。
            {
                continue;
            }
            
            check[i]=true;
            path.push_back(nums[i]);
            dfs(nums);
            check[i]=false;
            path.pop_back();
        }
    }
};

17. 电话号码

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    vector<string> ret;
    string path;
    vector<string> hash={" ", " ", "abc", "def", "ghi","jkl","mno","pqrs","tuv","wxyz"};

    vector<string> letterCombinations(string digits) 
    {
        if(digits.size()==0){
            return ret;
        }
        dfs(digits,0);
        return ret;
    }

    void dfs(string& digits,int pos)
    {

        if(path.size()==digits.size())
        {
            ret.push_back(path);
            return;
        }

        for(auto a: hash[digits[pos]-'0'] )
        {
            path.push_back(a);
            dfs(digits,pos+1);
            path.pop_back();
        }
    }
};

18. 括号生成

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    int max;
    int left,right;
    vector<string> ret;
    string path;
    vector<string> generateParenthesis(int n)
    {
        max=n;
        dfs();
        return ret;
    }

    void dfs()
    {
        if(right == max)
        {
            ret.push_back(path);
            return;
        }

        if(left < max)
        {
            path.push_back('(');
            ++left;
            dfs();
            --left;
            path.pop_back();
        }

        if(right < left)
        {
            path.push_back(')');
            right++;
            dfs();
            right--;
            path.pop_back();
        }
    }
};

19. 组合

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    int max;
    vector<int> path;
    vector<vector<int>> ret;
    vector<vector<int>> combine(int n, int k) {
        max=k;
        dfs(1,n);
        return ret;
    }

    void dfs(int pos,int& n)
    {
        if(path.size() == max )
        {
            ret.push_back(path);
            return;
        }

        for(int i=pos;i<n+1;++i)
        {
            path.push_back(i);
            dfs(i+1,n);//是要传入i+1而不是pos+1
            path.pop_back();
        }
    }
};

20.目标和

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

注意单单int的反复加加减减还是非常耗时的，这里不是拷贝一个vector之类的对象，所以反而恢复现场的操作会更慢从而超时。

class Solution {
public:
    // int ret=0;
    // int path;
    // int now_target;
    // int findTargetSumWays(vector<int>& nums, int target) 
    // {
    //     now_target=target;
    //     dfs(0,1,nums);
    //     return ret;

    // }

    // void dfs(int pos,int level,vector<int>& nums)
    // {
    //     if(nums.size()+1 == level)
    //     {
    //         if(path==now_target)
    //         {
    //             ret++;
    //         }
    //         return;
    //     }

    //     {
    //         path+=nums[pos];
    //         dfs(pos+1,level+1,nums);
    //         path-=nums[pos];
    //     }

    //     {
    //         path-=nums[pos];
    //         dfs(pos+1,level+1,nums);
    //         path+=nums[pos];
    //     }
    // }
    int ret=0;
    //int path;
    int now_target;
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int path=0;
        now_target=target;
        dfs(0,1,nums,path);
        return ret;

    }

    void dfs(int pos,int level,vector<int>& nums,int path)
    {
        if(nums.size()+1 == level)
        {
            if(path==now_target)
            {
                ret++;
            }
            return;
        }

        {
            //path+=nums[pos];
            dfs(pos+1,level+1,nums,path+nums[pos]);
            //path-=nums[pos];
        }

        {
            dfs(pos+1,level+1,nums,path-nums[pos]);
        }
    }

};

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

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

相关文章

【二本同学的秋招那些事儿】——中秋国庆双节快乐

【二本同学的秋招那些事儿】——中秋国庆双节快乐

&#x1f4a7; 二本同学的秋招那些事儿 \color{#FF1493}{二本同学的秋招那些事儿} 二本同学的秋招那些事儿&#x1f4a7; &#x1f337; 仰望天空&#xff0c;妳我亦是行人.✨ &#x1f984; 个人主页——微风撞见云的博客&#x1f390; &#x1f433; 《数据结构与算…
阅读更多...
求求，别在sql里格式化数据了

求求，别在sql里格式化数据了

在shigen之前的文章《为什么我们总是被追赶着走》这篇文章中提到了很多的设计乱象&#xff0c;设计的恶心之处至今让我呕吐。其中的sql我说了动辄上百行&#xff0c;而一些略长的部分竟然就是为了一件事——格式化。我直接一个ca&#xff0c;格式化不能用一个VO去处理吗&#x…
阅读更多...
【C++进阶(六)】STL大法--栈和队列深度剖析优先级队列适配器原理

【C++进阶(六)】STL大法--栈和队列深度剖析优先级队列适配器原理

&#x1f493;博主CSDN主页:杭电码农-NEO&#x1f493;   ⏩专栏分类:C从入门到精通⏪   &#x1f69a;代码仓库:NEO的学习日记&#x1f69a;   &#x1f339;关注我&#x1faf5;带你学习C   &#x1f51d;&#x1f51d; 栈和队列 1. 前言2. 栈和队列的接口函数熟悉3. …
阅读更多...
django 实现：闭包表—树状结构

django 实现：闭包表—树状结构

闭包表—树状结构数据的数据库表设计 闭包表模型 闭包表&#xff08;Closure Table&#xff09;是一种通过空间换时间的模型&#xff0c;它是用一个专门的关系表&#xff08;其实这也是我们推荐的归一化方式&#xff09;来记录树上节点之间的层级关系以及距离。 场景 我们 …
阅读更多...
百度交易中台之内容分润结算系统架构浅析

百度交易中台之内容分润结算系统架构浅析

作者 | 交易中台团队 导读 随着公司内容生态的蓬勃发展&#xff0c;内容产出方和流量提供方最关注的“收益结算”的工作&#xff0c;也就成为重中之重。本文基于内容分润结算业务为入口&#xff0c;介绍了实现过程中的重难点&#xff0c;比如千万级和百万级数据量下的技术选型和…
阅读更多...
使用 AI 编程助手 CodeWhisperer，开发如有神助

使用 AI 编程助手 CodeWhisperer，开发如有神助

前段时间体验了chatGPT&#xff0c;听说它可以写代码&#xff0c;结果发现更多的只是一个对答写小作文的百度助手&#xff0c;虽然也能写代码&#xff0c;但不是我想要的&#xff0c;可以在 idea 中可以快速生成代码块的。一个偶然的机会&#xff0c;从微信群里了解到&#xff…
阅读更多...
科技云报道：大模型的阴面：无法忽视的安全隐忧

科技云报道：大模型的阴面：无法忽视的安全隐忧

科技云报道原创。 在AI大模型的身上&#xff0c;竟也出现了“to be or not to be”问题。 争议是伴随着大模型的能力惊艳四座而来的&#xff0c;争议的核心问题在于安全。安全有两个方面&#xff0c;一个是大模型带来的对人类伦理的思考&#xff0c;一个是大模型本身带来的隐…
阅读更多...
Unity实现设计模式——解释器模式

Unity实现设计模式——解释器模式

Unity实现设计模式——解释器模式 解释器模式&#xff08;Interpreter Pattern&#xff09;是一种按照规定语法进行解析的模式&#xff0c;现实项目中用得较少。 给定一门语言&#xff0c;定义它的文法的一种表示&#xff0c;并定义一个解释器&#xff0c;该解释器使用该表示来…
阅读更多...
在windows的ubuntu LTS中安装及使用EZ-InSAR进行InSAR数据处理

在windows的ubuntu LTS中安装及使用EZ-InSAR进行InSAR数据处理

EZ-InSAR&#xff08;曾被称为MIESAR&#xff0c;即Matlab界面用于易于使用的合成孔径雷达干涉测量&#xff09;是一个用MATLAB编写的工具箱&#xff0c;用于通过易于使用的图形用户界面&#xff08;GUI&#xff09;进行干涉合成孔径雷达&#xff08;InSAR&#xff09;数据处理…
阅读更多...
网络基础（了解网络知识的前提）

网络基础（了解网络知识的前提）

前言 在正式学习网络之前&#xff0c;我们需要了解的一些关于计算机网络的基本知识&#xff0c;本文主要阐述这些基本知识&#xff0c;带着大家一步一步迈进互联网网络的世界&#xff1b; 一、局域网与广域网的概念 在正式了解这些概念的前提是我们要搞懂网络出现的意义&#x…
阅读更多...
Linux高级应用——web网站服务

Linux高级应用——web网站服务

作者简介&#xff1a;一名云计算网络运维人员、每天分享网络与运维的技术与干货。 公众号&#xff1a;网络豆云计算学堂 座右铭&#xff1a;低头赶路&#xff0c;敬事如仪 个人主页&#xff1a; 网络豆的主页​​​​​ 目录 前言 一.Apache 1.Apache介绍 2.Apache的特…
阅读更多...
【AI绘画】Stable Diffusion WebUI

【AI绘画】Stable Diffusion WebUI

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
gitee 远程仓库操作基础(一)

gitee 远程仓库操作基础(一)

git remote add <远程仓库名> <仓库远程地址> :给远程仓库取个别名,简化一大堆字符串操作 git remote add origin xxx.git :取个Origin名字 git remote -v :查看本地存在的远程仓库 git pull <远程仓库名><远程分支名>:<本地分支名> 相同可取消…
阅读更多...
【SpringBoot实践】事务和事务传播机制失效原因正确使用事务的建议

【SpringBoot实践】事务和事务传播机制失效原因正确使用事务的建议

文章目录 1.概述2.事务与事务传播2.1 声明式事务说明2.2.声明式事务失效原因2.3.事务的传播机制2.4.事务传播失效原因 3.事务使用建议4.总结 1.概述 我们在开发工作中经常会使用到事务&#xff0c;来保证数据库做增、删、改操作时的数据一致性&#xff0c;在使用Spring来处理事…
阅读更多...
【c语言】通讯录【动态版本：有排序和文件操作】

【c语言】通讯录【动态版本：有排序和文件操作】

目录 一、通讯录定义 二、通讯录的实现 1、test.c中菜单的实现 2、通讯录的创建逻辑 3、初始化 4、检查容量和添加 5、查找 6、删除功能 7、修改功能 8、打印 9、查找并打印 10、qsort排序 11、摧毁 12、保存数据到文件 13、从文件中读数据 完整代码&#xff1a; 一、通讯录定…
阅读更多...
Windows上安装 Go 环境

Windows上安装 Go 环境

一、下载go环境 下载go环境&#xff1a;Go下载官网链接找到自己想下载的版本&#xff0c;点击下载&#xff0c;比如我这是windows64位的&#xff0c;我就直接点击最新的。 二、安装go环境 双击下载的.msi文件 next next 他默认的是c盘&#xff0c;你自己可以改&#xff0c;然…
阅读更多...
Android 导入ncnn-android-yolov8-seg : 实现人体识别和人像分割

Android 导入ncnn-android-yolov8-seg : 实现人体识别和人像分割

1. 前言 上篇文章我们在Android中使用OpenCV实现了人脸识别&#xff0c;这篇文章我们使用OpenCVYOLOv8NCNN 来实现人像分割的功能。 首先来看下效果&#xff0c;这里会识别出人体&#xff0c;并会用蓝色的框框出来&#xff0c;并会有标签标注识别出的物体是什么&#xff0c;概…
阅读更多...
Python爬虫实战案例——第六例

Python爬虫实战案例——第六例

文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff01;严禁将文中内容用于任何商业与非法用途&#xff0c;由此产生的一切后果与作者无关。若有侵权&#xff0c;请联系删除。 目标&#xff1a;去哪儿网指定城市人气值最高的15个景点评论数据采集 地址&a…
阅读更多...
趣解设计模式之《小王的披萨店》

趣解设计模式之《小王的披萨店》

〇、小故事 小王看到最近越来越多的人喜欢吃披萨了&#xff0c;所以&#xff0c;他决定自己也开一个披萨店。最初开的时候&#xff0c;他只提供了一种口味的披萨&#xff0c;因为这样先试试水&#xff0c;看看生意如何&#xff0c;如果生意不好&#xff0c;也可以快速止损。 没…
阅读更多...
一道签到题目 签到.zip

一道签到题目 签到.zip

一道签到题目 https://www.xuenixiang.com/ctfexercise-competition-589.html 下载附件&#xff1a;签到.zip双击打开zip包。 进行base64转换 在线 Unicode 编码转换 | 菜鸟工具 (runoob.com) 获得压缩包密码&#xff1a;haishi 文字倒序工具,在线文字倒序 (qqxiuzi.cn)
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023