LeetCode # 树（持续更新中...)

最新推荐文章于 2021-09-13 15:03:07 发布
最新推荐文章于 2021-09-13 15:03:07 发布
阅读量146 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44305051/article/details/107731467
版权

1.
给你一棵以 root 为根的二叉树和一个 head 为第一个节点的链表。

如果在二叉树中，存在一条一直向下的路径，且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True ，否则返回 False 。

一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。

示例 1：

在这里插入图片描述

输入：
head = [4,2,8],
root =[1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
输出：true
解释：树中蓝色的节点构成了与链表对应的子路径。

示例 2：

在这里插入图片描述

输入：
head = [1,4,2,6],
root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
输出：true

示例 3：

输入：
head = [1,4,2,6,8],
root [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
输出：false
解释：二叉树中不存在一一对应链表的路径。

提示：

二叉树和链表中的每个节点的值都满足 1 <= node.val <= 100 。
链表包含的节点数目在 1 到 100 之间。
二叉树包含的节点数目在 1 到 2500 之间。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSubPath(ListNode* head, TreeNode* root) {
        if(head==nullptr)return true;
        if(root==nullptr)return false;
        return dfs(head,root)||isSubPath(head,root->left)||isSubPath(head,root->right);
    }
    bool dfs(ListNode* head, TreeNode* root){
        if(head==nullptr)return true;
        if(root==nullptr)return false;
        if(head->val!=root->val)return false;
        return dfs(head->next,root->left)||dfs(head->next,root->right);
    }
};

2.
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：
[ 3,9,20,null,null,15,7],

在这里插入图片描述

返回其层次遍历结果：

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //dfs
class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> levelOrder(TreeNode* root) {
        dfs(root,0);
        return res;
    }
    void dfs(TreeNode* root,int level)
    {
        if(!root)return;
        vector<int> que;
        if(level>=res.size())
            res.push_back(que);
        res[level].push_back(root->val);
        dfs(root->left,level+1);
        dfs(root->right,level+1);
    }
};
//bfs
class Solution {
public:  
    vector<vector<int>> levelOrder(TreeNode* root) {
       vector<vector<int>> res;
       if(!root)return {};
       queue<TreeNode*> q;
       q.push(root);
       while(!q.empty()){
           int CurrentLevel = q.size();
           vector<int> que;
           for(int i=0;i<CurrentLevel;i++){
               TreeNode* node=q.front();
               q.pop();
               que.push_back(node->val);
               if(node->left)q.push(node->left);
               if(node->right)q.push(node->right);
            }
            res.push_back(que);
       }
       return res;
    }
};

3.
本题用到了一个数据结构叫做并查集，不了解并查集的可以先去网上学习，推介一个视频，本人当时就是通过该视频学习的并查集。
信息学竞赛教程 第一讲 并查集 中文版

在本问题中, 树指的是一个连通且无环的无向图。

输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。

返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u < v。

示例 1：

在这里插入图片描述

示例 2：

在这里插入图片描述

注意:

输入的二维数组大小在 3 到 1000。
二维数组中的整数在1到N之间，其中N是输入数组的大小。

class Solution {
public: 
    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        vector<int> bcj(1001);
        int size=edges.size();
        for(int i=1;i<=size;i++)
            bcj[i]=i;
        for(int i=0;i<size;i++)
        {
            int ret1=Find(edges[i][0],bcj);
            int ret2=Find(edges[i][1],bcj);
            if(ret1!=ret2)
                bcj[ret2]=ret1;
            else
                return edges[i];
        }
        return {0,0};
    }
    int Find(int n,vector<int> &bcj)
    {
      if(n==bcj[n])return n;
      int num=bcj[n];
      return bcj[num]=Find(num,bcj);
    }
};

4.
给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

在这里插入图片描述

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

在这里插入图片描述

返回 false 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:   
    bool state=true;
    bool isBalanced(TreeNode* root) {
        dfs(root);
        return state;
    }
    void dfs(TreeNode* root){
        int m_nLeft=0;
        int m_nRight=0;
        if(!root)return; 
        if(root->left!=nullptr)m_nLeft=lenght(root->left);
        if(root->right!=nullptr)m_nRight=lenght(root->right);
        if(abs(m_nLeft-m_nRight)>1){
            state=false;
            return;
        }
        dfs(root->left);
        dfs(root->right);
    }
    int lenght(TreeNode* root){
        if(!root)return 0;
        return max(lenght(root->left),lenght(root->right))+1; 
    }
};

5.
给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。
示例：

输入：[1,2,3,4,5,null,7,8]

在这里插入图片描述

输出：[[1],[2,3],[4,5,7],[8]]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> res;
    vector<ListNode*> point;//保存每层链表最后一项的地址
    vector<ListNode*> listOfDepth(TreeNode* tree) {
        dfs(tree,0);
        return res;
    }
    void dfs(TreeNode* tree,int level){
        if(tree==nullptr)return;
        ListNode* k=new ListNode();
        k->val=tree->val;
        k->next=nullptr;
        if(level>=res.size()){
            res.push_back(k);
            point.push_back(k);
        }
        else
        {
            point[level]->next=k;
            point[level]=k;
        }
        dfs(tree->left,level+1);
        dfs(tree->right,level+1);
    }
};

6.
给定一个 N 叉树，返回其节点值的前序遍历。

例如，给定一个 3叉树 :
在这里插入图片描述

返回其前序遍历: [1,3,5,6,2,4]。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> res;
    vector<int> preorder(Node* root) {   
        dfs(root);
        return res;
    }
    void dfs(Node* root){
        if(!root)return;
        res.push_back(root->val);
        for(auto i:root->children){
            dfs(i);
        }
    }
};

7.
最大树定义：一个树，其中每个节点的值都大于其子树中的任何其他值。
给出最大树的根节点 root。
就像之前的问题那样，给定的树是从表 A（root = Construct(A)）递归地使用下述 Construct(A) 例程构造的：
如果 A 为空，返回 null
否则，令 A[i] 作为 A 的最大元素。创建一个值为 A[i] 的根节点 root
root 的左子树将被构建为 Construct([A[0], A[1], …, A[i-1]])
root 的右子树将被构建为 Construct([A[i+1], A[i+2], …, A[A.length - 1]])
返回 root
请注意，我们没有直接给定 A，只有一个根节点 root = Construct(A).
假设 B 是 A 的副本，并附加值 val。保证 B 中的值是不同的。
返回 Construct(B)。

We are given the root node of a maximum tree: a tree where every node has a value greater than any other value in its subtree.

Just as in the previous problem, the given tree was constructed from an list A (root = Construct(A)) recursively with the following Construct(A) routine:

If A is empty, return null.
Otherwise, let A[i] be the largest element of A. Create a root node with value A[i].
The left child of root will be Construct([A[0], A[1], …, A[i-1]])
The right child of root will be Construct([A[i+1], A[i+2], …, A[A.length - 1]])
Return root.
Note that we were not given A directly, only a root node root = Construct(A).

Suppose B is a copy of A with the value val appended to it. It is guaranteed that B has unique values.

Return Construct(B).

示例 1：
在这里插入图片描述

输入：root = [4,1,3,null,null,2], val = 5
输出：[5,4,null,1,3,null,null,2]
解释：A = [1,4,2,3], B = [1,4,2,3,5]
示例 2：

在这里插入图片描述

输入：root = [5,2,4,null,1], val = 3
输出：[5,2,4,null,1,null,3]
解释：A = [2,1,5,4], B = [2,1,5,4,3]
示例 3：

在这里插入图片描述

输入：root = [5,2,3,null,1], val = 4
输出：[5,2,4,null,1,3]
解释：A = [2,1,5,3], B = [2,1,5,3,4]

解释：
插入值大于根节点的值，则插入值变成根，原跟变成新根的左儿子 ；否则从根节点的右子树继续寻找，直到找到比插入值小的节点的值，将该节点作为插入值的左儿子，重构该树。

/**
 * 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* insertIntoMaxTree(TreeNode* root, int val) {
        if(!root)return new TreeNode(val);
        if(val>=root->val)
        {
            TreeNode* res=new TreeNode(val,root,nullptr);
            root=res;
        }
        else if(!root->right)
            root->right=new TreeNode(val);
        else
        {
            root->right=insertIntoMaxTree(root->right,val);

        }
        return root;
    }
};

8.
二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。

示例 1：
输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[2,1]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

//递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<Integer> ();
        fnc(root,res);
        return res;
    }
    public void fnc(TreeNode root,List<Integer> res)
    {
        if(root==null)return;
        fnc(root.left,res);
        res.add(root.val);
        fnc(root.right,res);
    }
}
//迭代
//递归算法中，在JAVA虚拟机中隐式维护了一个栈，迭代方法中将栈显式表达出来
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
    }
}

9.（考察同8）
递增顺序查找树
给你一个树，请你 按中序遍历 重新排列树，使树中最左边的结点现在是树的根，并且每个结点没有左子结点，只有一个右子结点。

示例 ：
在这里插入图片描述
提示：

给定树中的结点数介于 1 和 100 之间。
每个结点都有一个从 0 到 1000 范围内的唯一整数值。

//递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode increasingBST(TreeNode root) {
        List<Integer> res=new ArrayList<Integer>();
        fnc(root,res);
        return fnc1(res);    
 
    }
    //求中序遍历
    public void fnc(TreeNode root,List<Integer> res){
        if(root==null)return;
        fnc(root.left,res);
        res.add(root.val);
        fnc(root.right,res);
    }
    //得到新的树
    public TreeNode fnc1(List<Integer> res){
        if(res.isEmpty())return null;
        TreeNode root=new TreeNode(res.get(0));
        TreeNode move=root;
        for(int i=1;i<res.size();i++){
            TreeNode node=new TreeNode(res.get(i));
            move.right=node;
            move=node;
        }
        return root;
    }
}
//迭代
class Solution {
    public TreeNode increasingBST(TreeNode root) {
        if(root==null)return null;
        TreeNode res=new TreeNode();
        TreeNode move=res;
        Stack <TreeNode> st = new Stack<TreeNode>();
        while(root!=null||!st.empty()){
            while(root!=null){
                st.push(root);
                root=root.left;
            }
            TreeNode node=new TreeNode(st.peek().val);
            move.right=node;
            move=node;
            root=st.pop().right;         
        }
        return res.right;
    }
}
为光。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode 树（java）
GreenHand_D的博客
08-03 799
@[TOP](leetcode 树) 前中后序遍历 前序遍历：父节点 -> 左子节点 -> 右子节点 中序遍历：左子节点 -> 父节点 -> 右子节点 后序遍历：左子节点 -> 右子节点 -> 父节点 leetcode144 非递归实现二叉树的前序遍历（Medium） https://leetcode-cn.com/problems/binary-tree-preorder-traversal/ 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3
[链表]leetcode1367-二叉树中的列表
weixin_44014218的博客
12-13 142
[链表]–二叉树中的列表 题目链接 leetcode 1367.二叉树中的列表 题目 给你一棵以 root 为根的二叉树和一个 head 为第一个节点的链表。 如果在二叉树中，存在一条一直向下的路径，且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True ，否则返回 False 。 一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。 示例 输入：head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,n
Leetcode—链表专题(java版本)
qq_42265220的博客
09-13 532
链表专题一、链表简介链表的基操 一、链表简介 各种数据结构，不管是队列，栈等线性数据结构还是树，图的等非线性数据结构，从根本上底层都是数组和链表。不管你用的是数组还是链表，用的都是计算机内存，物理内存是一个个大小相同的内存单元构成的，如图： 而数组和链表里的数据虽然用的都是物理内存，都是两者在对物理内存的使用上是非常不一样的，如图： 数组是连续的内存空间，通常每一个单位的大小也是固定的，因此可以按下标随机访问。而链表则不一定连续，因此其查找只能依靠别的方式，一般我们是通过一个叫 next 指针来遍历查找
LeetCode Weekly Contest 178
da_kao_la的博客
03-01 284
5344. 有多少小于当前数字的数字 给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。 换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。 以数组形式返回答案。 示例 1： 输入：nums = [8,1,2,2,3] 输出：[4,0,1,1,3] 解释： ...
python二叉树增加节点_LeetCode | 0623. 在二叉树中增加一行【Python】
weixin_33291014的博客
03-02 290
问题给定一个二叉树，根节点为第1层，深度为 1。在其第 d 层追加一行值为 v 的节点。添加规则：给定一个深度值 d (正整数)，针对深度为 d-1 层的每一非空节点 N，为 N 创建两个值为 v 的左子树和右子树。将 N 原先的左子树，连接为新节点 v 的左子树；将 N 原先的右子树，连接为新节点 v 的右子树。如果 d 的值为 1，深度 d - 1 不存在，则创建一个新的根节点 v，原先的整棵...
【Leetcode题解】Leetcode题解持续更新....
YancyKahn
10-21 590
简单 844. 比较含退格的字符串（栈） 925. 长按键入 （字符串比较） 普通 143. 重排链表（转化成线性表） 困难
【Leetcode 题解】Leetcode分类 题解，持续更新.....
YancyKahn
10-29 1198
Leetcode分类 题解，持续更新… 文章目录Leetcode分类 题解，持续更新.....一、基础1. 水题2. 位运算3. 区间问题二、数据结构1. 基础数据结构1.1 栈1.2 链表1.3 队列2. 树2.1 二叉树三、算法1. 动态规划2. 贪心3. 排序 一、基础 1. 水题 925. 长按键入 （字符串比较） 1207. 独一无二的出现次数 （水题，击败100% 用户时间！） 1365. 有多少小于当前数字的数字（排序预处理，线性求解） 2. 位运算 234. 回文链表 （异或法求解，空间复
【LeetCode刷题日记】持续更新中...
梁瑛平的博客
02-04 644
【LeetCode刷题日记】持续更新中...Day-06-2021-02-04-栈基础题：224. 基本计算器155. 最小栈150. 逆波兰表达式求值Day-05-2021-02-03-基础题：102. 二叉树的层序遍历（递归）102. 二叉树的层序遍历（队列）103. 二叉树的锯齿形层序遍历Day-04-2021-02-02-基础题：42. 接雨水20. 有效的括号94. 二叉树的中序遍历96. 不同的二叉搜索树Day-03-2021-02-01-链表基础题：61. 旋转链表82. 删除排序链表中的重复
LeetCode、机器学习、Python.zip
04-09
随着统计学的发展，统计学习在机器学习中占据了重要地位，支持向量机（SVM）、决策树和随机森林等算法的提出和发展，使得机器学习能够更好地处理分类、回归和聚类等任务。进入21世纪，深度学习成为机器学习领域的...
Leetcode-master (1).rar
10-09
3. 持续挑战：LeetCode 提供了丰富的题目，涵盖各个难度等级。持续解题可以锻炼编程思维，逐步提高编程能力。 总结，"Leetcode-master (1).rar" 提供了一个宝贵的学习资源，让我们有机会深入理解并实践各种编程问题...
php-leetcode题解之二叉搜索树中的搜索.zip
06-08
在本压缩包“php-leetcode题解之二叉搜索树中的搜索.zip”中，主要包含的是关于使用PHP解决LeetCode上二叉搜索树（BST）搜索问题的代码和解析。LeetCode是一个在线平台，提供了大量的编程题目，用于提升开发者的技术...
上班时间刷leetcode-leetcode.go.learning:leetcode学习
06-30
【标题】"上班时间刷leetcode-leetcode.go.learning:leetcode学习" 涉及的主要知识点是通过使用Go语言在工作间隙解决LeetCode上的编程题目来提升技能。LeetCode是一个在线平台，提供了一系列算法和数据结构问题，...
leetcode中文版-study.github.io:学习.github.io
06-29
leetcode中文版编程面试大学 我最初创建它是为了成为一名软件工程师的学习主题的简短待办事项列表，但它增长到您今天看到的大列表。 完成这个学习计划后，！ 你可能不需要像我一样学习。 总之，你需要的都在这里。 ...
51浅析建设工程全过程造价管理.docx
09-12
51浅析建设工程全过程造价管理
31工程量清单计价模式下的造价控制与管理.docx
09-12
31工程量清单计价模式下的造价控制与管理
Java毕业设计基于SSM+mysql的学生宿舍管理系统源码+数据库（高分代码）
09-12
Java毕业设计基于SSM+mysql的学生宿舍管理系统源码+数据库（高分代码），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。 包含：项目源码、数据库脚本等，该项目可以作为毕设、课程设计使用，前后端代码都在里面。该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。项目都经过严格调试，确保可以运行！可以放心下载。 Java毕业设计基于SSM+mysql的学生宿舍管理系统源码+数据库（高分代码），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。 包含：项目源码、数据库脚本等，该项目可以作为毕设、课程设计使用，前后端代码都在里面。该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。项目都经过严格调试，确保可以运行！可以放心下载。 Java毕业设计基于SSM+mysql的学生宿舍管理系统源码+数据库（高分代码），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。 包含：项目
c++课程设计-个人收支管理系统.zip
09-12
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
js逆向-安某客空间推理验证码验证流程分析
09-12
js逆向-安某客空间推理验证码验证流程分析
ssm+mysql的在线汽车交易系统(源码+lw+ppt)
最新发布
09-12
内容概要： SSM汽车交易系统是一个基于B/S架构的在线汽车销售平台，采用JAVA、MySQL和JavaScript技术开发。系统提供汽车展示、新闻发布、用户注册登录、在线留言和订单管理等功能，界面友好，操作简便，满足现代汽车销售的多样化需求。 适用人群： 适用于汽车销售企业、经销商以及电子商务平台开发者和IT专业学生。 使用场景及目标： 1. 汽车销售企业可以通过平台展示汽车，吸引客户，提升销售效率。 2. 经销商利用系统进行库存和客户管理，简化交易流程。 3. 开发者和学生可参考系统架构，学习Web应用开发。 其它说明： 系统设计注重用户体验，后台管理功能强大，支持数据安全和权限控制，保障用户信息安全。系统具有良好的扩展性，可随业务发展进行功能升级。
LeetCode算法全解：数据结构与经典题型视频教程
在本资源中，我们涵盖了LeetCode中广泛涉及的数据结构与算法题型，这对于提高编程技能和解决实际问题具有重要意义。以下是一些关键知识点的详细解析： 1. **栈与队列**： - 栈（Stack）是后进先出（LIFO）的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值