代码随想录学习笔记---二叉树

学习目标：

学习代码随想录–二叉树

  • 每天学习1道,复习两道

学习内容：

2025.4.7
复习内容:
24. 两两交换链表中的节点
25. 最大二叉树

学习内容
26. 合并二叉树

2025.4.8
复习内容:
27. 二分查找
28. 合并二叉树
29. 27. 移除元素

学习内容:
30. 二叉搜索树中的搜索

2025.4.9
学习内容:
98. 验证二叉搜索树

2025.4.11
学习内容:
99. 验证二叉搜索树 – 迭代法
530. 二叉搜索树的最小绝对差

复习内容:
977. 有序数组的平方
209. 长度最小的子数组

2025.4.12忘了保存了

2025.4.13
学习内容:
236. 二叉树的最近公共祖先

复习内容:
237. 二叉搜索树中的众数
58.区间和

2025.4.14
学习内容:
238. 二叉搜索树的最近公共祖先

复习内容:
236. 二叉树的最近公共祖先
44. 开发商购买土地（第五期模拟笔试）

2025.4.15
学习内容:
701. 二叉搜索树中的插入操作

复习内容:
235. 二叉搜索树的最近公共祖先
203. 移除链表元素

2025.4.21
学习内容
450. 删除二叉搜索树中的节点
669. 修剪二叉搜索树

2025.4.22
学习内容:
108. 将有序数组转换为二叉搜索树

2025.4.23
学习内容:
538. 把二叉搜索树转换为累加树

复习内容:
450. 删除二叉搜索树中的节点
669. 修剪二叉搜索树

2025.4.25
复习内容:
538. 把二叉搜索树转换为累加树
108. 将有序数组转换为二叉搜索树
669. 修剪二叉搜索树
450. 删除二叉搜索树中的节点

学习产出：

**

2025.4.7

**

24.交换链表中的节点

ListNode* swapPairs(ListNode* head) {ListNode* dummyHead = new ListNode();dummyHead -> next = head;ListNode* node = dummyHead;while (node -> next != nullptr && node -> next -> next != nullptr){ListNode* cur = node -> next;ListNode* curNext = node -> next -> next -> next;node -> next = node -> next -> next;node -> next -> next = cur;node -> next -> next -> next = curNext;node = node -> next -> next;}head = dummyHead -> next;delete(dummyHead);return head;}

654. 最大二叉树

TreeNode* constructMaximumBinaryTree(vector<int>& nums) {TreeNode* root = new TreeNode();if (nums.size() == 1){root -> val = nums[0];return root;}int maxIndex = 0, maxValue = INT_MIN;for (int i = 0; i < nums.size(); i++){if (maxValue < nums[i]){maxIndex = i;maxValue = nums[i];}}root -> val = maxValue;//分割数组if (maxIndex > 0){vector<int> leftNums(nums.begin(), nums.begin() + maxIndex);root -> left = constructMaximumBinaryTree(leftNums);}if (maxIndex < nums.size() - 1){vector<int> rightNums(nums.begin() + maxIndex + 1, nums.end());root -> right = constructMaximumBinaryTree(rightNums);}return root;}

617. 合并二叉树

//递归法 --- 前序遍历TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {if (root1 == nullptr) return root2;if (root2 == nullptr) return root1;root1 -> val += root2 -> val;root1 -> left = mergeTrees(root1 -> left, root2 -> left);root1 -> right = mergeTrees(root1 -> right, root2 -> right);return root1;}

//迭代法TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {if (root1 == nullptr) return root2;if (root2 == nullptr) return root1;queue<TreeNode*> que;que.push(root1);que.push(root2);while (!que.empty()){TreeNode* node1 = que.front(); que.pop();TreeNode* node2 = que.front(); que.pop();node1 -> val += node2 -> val;if (node1 -> left != nullptr && node2 -> left != nullptr){que.push(node1 -> left);que.push(node2 -> left);}if (node1 -> right != nullptr && node2 -> right != nullptr){que.push(node1 -> right);que.push(node2 -> right);}if (node1 -> left == nullptr && node2 -> left != nullptr){node1 -> left = node2 -> left;}if (node1 -> right == nullptr && node2 -> right != nullptr){node1 -> right = node2 -> right;}}return root1;}

**

2025.4.8

704. 二分查找

int findLeftEnd(vector<int> nums, int target){int l = 0, r = nums.size() - 1;while (l < r){int mid = (l + r + 1) >> 1;if (nums[mid] > target) r = mid - 1;else l = mid;}return l;}int findRightFirst(vector<int> nums, int target){int l = 0, r = nums.size() - 1;while (l < r){int mid = (l + r) >> 1;if (nums[mid] >= target) r = mid;else l = mid + 1;}return l;}//上面两种方法都可以,可以看实际应用场景进行使用int search(vector<int>& nums, int target) {//int ans = findLeftEnd(nums, target);int ans = findRightFirst(nums, target);if (nums[ans] == target) return ans;return -1;}

27. 移除元素

//双指针算法int removeElement(vector<int>& nums, int val) {int count = 0;for (int i = 0; i < nums.size(); i++){if (nums[i] != val){nums[count++] = nums[i];}}return count;}

700. 二叉搜索树中的搜索

//递归法
TreeNode* searchBST(TreeNode* root, int val) {if (root == nullptr || root -> val == val) return root;TreeNode* node = new TreeNode();if (root -> val > val) node = searchBST(root -> left, val);else node = searchBST(root -> right, val);return node;}

//迭代法TreeNode* searchBST(TreeNode* root, int val) {while (root != nullptr){if (root -> val > val) root = root -> left;else if (root -> val < val) root = root -> right;else return root;}return nullptr;}

2025.4.9

98. 验证二叉搜索树

	//递归(中序遍历)TreeNode* pre = nullptr;bool isValidBST(TreeNode* root) {if (root == nullptr) return true;bool left = isValidBST(root -> left);if (pre != nullptr && pre -> val >= root -> val) return false;pre =  root;bool right = isValidBST(root -> right);return left && right;}

//递归将节点值存入数组(中序遍历)vector<int> nums;void traversal(TreeNode* node){if (node -> left != nullptr) traversal(node -> left);nums.push_back(node -> val);if (node -> right != nullptr) traversal(node -> right);}bool isValidBST(TreeNode* root) {nums.clear();if (root == nullptr) return true;traversal(root);for (int i = 1; i < nums.size(); i++){if (nums[i - 1] >= nums[i]) return false;}return true;}

2025.4.11

98. 验证二叉搜索树 – 迭代法

TreeNode* maxNode;bool isValidBST(TreeNode* root) {stack<TreeNode*> stk;if (root != nullptr) stk.push(root);TreeNode* maxNode = nullptr;while (!stk.empty()){TreeNode* node = stk.top();stk.pop();if (node != nullptr){if (node -> right) stk.push(node -> right);stk.push(node);stk.push(nullptr);if (node -> left) stk.push(node -> left);}else{node = stk.top();stk.pop();if (maxNode == nullptr || maxNode -> val < node -> val) maxNode = node;else return false;}}return true;}

530. 二叉搜索树的最小绝对差

//递归数组
public:vector<int> nums;void traversal(TreeNode* node){if (node -> left != nullptr) traversal(node -> left);nums.push_back(node -> val);if (node -> right != nullptr) traversal(node -> right);}int getMinimumDifference(TreeNode* root) {nums.clear();traversal(root);int result = INT_MAX;for (int i = 1; i < nums.size(); i++){result = min(result, nums[i] - nums[i - 1]);}return result;}

//递归记录前序节点
public:TreeNode* preNode = nullptr;int result = INT_MAX;void traversal(TreeNode* node){if (node -> left != nullptr) traversal(node -> left);if (preNode != nullptr){result = min(result, node -> val - preNode -> val);}preNode = node;if (node -> right != nullptr) traversal(node -> right);}int getMinimumDifference(TreeNode* root) {traversal(root);return result;}

2025.4.13

//迭代法
public:TreeNode* preNode = nullptr;int result = INT_MAX;int getMinimumDifference(TreeNode* root) {stack<TreeNode*> stk;if (root != nullptr) stk.push(root);while (!stk.empty()){TreeNode* node = stk.top();stk.pop();if (node != nullptr){if (node -> right != nullptr) stk.push(node -> right);stk.push(node);stk.push(nullptr);if (node -> left != nullptr) stk.push(node -> left); }else{node = stk.top();stk.pop();if (preNode != nullptr) result = min(result, node -> val - preNode -> val);preNode = node;}}return result;}

977. 有序数组的平方

//暴力做法,直接平方+快排void quick_sort(vector<int> &nums, int l, int r){if (l >= r) return;int x = nums[(l + r) >> 1];int i = l - 1, j = r + 1;while (i < j){do i++; while (x > nums[i]);do j--; while (x < nums[j]);if (i < j) swap(nums[i], nums[j]);}quick_sort(nums, l, j);quick_sort(nums, j + 1, r);}vector<int> sortedSquares(vector<int>& nums) {for (int i = 0; i < nums.size(); i++){nums[i] *= nums[i];}quick_sort(nums, 0, nums.size() - 1);return nums;}

//双指针法
public:vector<int> sortedSquares(vector<int>& nums) {int i = 0, j = nums.size() - 1;//初始化vector<int> result(nums.size(), 0);int k = j;while (k >= 0){if (nums[i] * nums[i] > nums[j] * nums[j]){   result[k] = nums[i] * nums[i];i++;} else{result[k] = nums[j] * nums[j];j--;}k--;}return result;}

209. 长度最小的子数组

public://滑动窗口int minSubArrayLen(int target, vector<int>& nums) {int minLength = INT_MAX;int i = 0;int result = 0;for (int j = 0; j < nums.size(); j++){result += nums[j];while (result >= target){minLength = min(minLength, j - i + 1);result -= nums[i++];}}return minLength == INT_MAX ? 0 : minLength;}

236. 二叉树的最近公共祖先

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {if (root == p || root == q || root == nullptr) return root;TreeNode* right = lowestCommonAncestor(root -> right, p, q);TreeNode* left = lowestCommonAncestor(root -> left, p, q);if (left != nullptr && right != nullptr) return root;if (left != nullptr && right == nullptr) return left;else if (left == nullptr && right != nullptr) return right;else return nullptr;}

501. 二叉搜索树中的众数

//作为普通二叉树
void traversal(TreeNode* node, unordered_map<int, int> &map){//前序遍历map[node -> val]++;if (node -> left) traversal(node -> left, map);if (node -> right) traversal(node -> right, map);}bool static cmp(const pair<int, int> &A, const pair<int, int> &B){return A.second > B.second;}vector<int> findMode(TreeNode* root) {unordered_map<int, int> map;traversal(root, map);vector<pair<int, int>> nums(map.begin(), map.end());sort(nums.begin(), nums.end(), cmp);vector<int> result;result.push_back(nums[0].first);for (int i = 1; i < nums.size(); i++){if (nums[i].second == nums[0].second) result.push_back(nums[i].first);else break;}return result;}

//利用二叉搜索树的特性:中序遍历有序
TreeNode* preNode;int maxCount = 0;int count = 0;vector<int> result;void traversal(TreeNode* node){if (node -> left) traversal(node -> left);if (preNode == nullptr) count = 1;if (preNode != nullptr && preNode -> val != node -> val){count = 1;}else if (preNode != nullptr && preNode -> val == node -> val){count++;}//清空数组,重新添加众数if (count > maxCount){result.clear();maxCount = count;result.push_back(node -> val);}else if (count == maxCount) result.push_back(node -> val);preNode = node;if (node -> right) traversal(node -> right);}vector<int> findMode(TreeNode* root) {if (root == nullptr) return result;traversal(root);return result;}

58.区间和

#include <iostream>
#include <vector>using namespace std;int main()
{int n;int a, b;cin >> n;vector<int> nums(n);vector<int> sums(n);int preSum = 0;for (int i = 0; i < n; i++){cin >> nums[i];preSum += nums[i];sums[i] = preSum;}while (cin >> a >> b){int ans = 0;if (a == 0) ans = sums[b];else ans = sums[b] - sums[a - 1];cout << ans << endl;}
}

2025.4.14

235. 二叉搜索树的最近公共祖先

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {if (root == nullptr) return root;if (root -> val > p -> val && root -> val > q -> val){TreeNode* left = lowestCommonAncestor(root -> left, p, q);if (left != nullptr) return left;}if (root -> val < p -> val && root -> val < q -> val){TreeNode* right = lowestCommonAncestor(root -> right, p, q);if (right != nullptr) return right;}return root;}

44. 开发商购买土地（第五期模拟笔试）

#include <iostream>
#include <vector>
#include <climits>using namespace std;int main()
{int n, m;cin >> n >> m;vector<vector<int>> nums(n, vector<int>(m, 0));int sum = 0;for (int i = 0; i < n; i++)for (int j = 0; j < m; j++){cin >> nums[i][j];sum += nums[i][j];}vector<int> horizontal(n, 0);for (int i = 0; i < n; i++)for (int j = 0; j < m; j++)horizontal[i] += nums[i][j];vector<int> vertical(m, 0);for (int j = 0; j < m; j++)for (int i = 0; i < n; i++)vertical[j] += nums[i][j];int result = INT_MAX;int horizontalCut = 0;for (int i = 0; i < n; i++){//这块才实现了横向的区间和horizontalCut += horizontal[i];result = min(result, abs(sum - horizontalCut - horizontalCut));}int verticalCut = 0;for (int j = 0; j < m; j++){//这块实现了纵向的区间和verticalCut += vertical[j];result = min(result, abs(sum - verticalCut - verticalCut));}cout << result << endl;
}

2025.4.15

701. 二叉搜索树中的插入操作

//存在返回值的递归TreeNode* insertIntoBST(TreeNode* root, int val) {if (root == nullptr){TreeNode* node = new TreeNode(val);return node;}if (root -> val > val) root -> left = insertIntoBST(root -> left, val);if (root -> val < val) root -> right = insertIntoBST(root -> right, val);return root;}

//无返回值的递归:利用parent记录TreeNode* parent;void traversal(TreeNode* node, int val){if (node == nullptr){TreeNode* cur = new TreeNode(val);if (parent -> val > val) parent -> left = cur;else parent -> right = cur;return;}parent = node;if (node -> val > val) traversal(node -> left, val);else traversal(node -> right, val);return;}TreeNode* insertIntoBST(TreeNode* root, int val) {//因为存在空节点测试的案例,所以一定要有这个判断if (root == nullptr){root = new TreeNode(val);return root;}traversal(root, val);return root;}

//迭代法:通过大左小右的方式,先找到空节点,同时也利用parent记录上一个节点TreeNode* insertIntoBST(TreeNode* root, int val) {if (root == nullptr){root = new TreeNode(val);return root;}TreeNode* cur = root;TreeNode* parent;while (cur != nullptr){parent = cur;if (cur -> val > val) cur = cur -> left;else cur = cur -> right;}TreeNode* node = new TreeNode(val);if (parent -> val > val) parent -> left = node;else parent -> right = node;return root;}

203. 移除链表元素

ListNode* removeElements(ListNode* head, int val) {ListNode* dummyHead = new ListNode();dummyHead -> next = head;ListNode* cur = dummyHead;while (cur -> next != nullptr){if (cur -> next -> val == val){ListNode* x = cur -> next;cur -> next = cur -> next -> next;delete(x);}else//关注这个位置,因为判断的是cur -> next不为空,所以上面需要更新cur时,下面就不需要更新了,只有cur -> val != val的时候,才需要更新cur的值cur = cur -> next;}head = dummyHead -> next;return head;}

2025.4.21

450. 删除二叉搜索树中的节点

//删除二叉排序树的节点---递归TreeNode* deleteNode(TreeNode* root, int key) {if (root == nullptr) return root;if (root -> val > key) root -> left = deleteNode(root -> left, key);else if (root -> val < key) root -> right = deleteNode(root -> right, key);if (root -> val == key){//左右子节点为空if (root -> left == nullptr && root -> right == nullptr){delete root;return nullptr;}//左节点为空if (root -> left == nullptr){TreeNode* resNode = root -> right;delete root;return resNode;}//右节点为空else if (root -> right == nullptr){TreeNode* resNode = root -> left;delete root;return resNode;}//左右节点都不为空else{//先找到右子树的最左节点TreeNode* cur = root -> right;while (cur -> left != nullptr){cur = cur -> left;}cur -> left = root -> left;TreeNode* resNode = root -> right;delete root;return resNode;}}return root;}

//迭代法(与递归法的删除逻辑相同,不同的只有遍历)TreeNode* deleteOneNode(TreeNode* node){if (node == nullptr) return node;if (node -> left == nullptr && node -> right == nullptr){delete node;return nullptr;}if (node -> left == nullptr){TreeNode* resNode = node -> right;delete node;return resNode;}else if (node -> right == nullptr){TreeNode* resNode = node -> left;delete node;return resNode;}else{TreeNode* cur = node -> right;while (cur -> left != nullptr){cur = cur -> left;}cur -> left = node -> left;TreeNode* resNode = node -> right;delete node;return resNode;}}TreeNode* deleteNode(TreeNode* root, int key) {TreeNode* cur = root, *pre = nullptr;while (cur){if (cur -> val == key) break;pre = cur;if (cur -> val > key) cur = cur -> left;else cur = cur -> right;}//根节点被删除if (pre == nullptr){root = deleteOneNode(cur);return root;}if (pre -> left && pre -> left -> val == key){pre -> left = deleteOneNode(cur);}if (pre -> right && pre -> right -> val == key){pre -> right = deleteOneNode(cur);}return root;}

669. 修剪二叉搜索树

//递归法TreeNode* trimBST(TreeNode* root, int low, int high) {if (root == nullptr) return nullptr;if (root -> val > high){TreeNode* left = trimBST(root -> left, low, high);return left;}if (root -> val < low){TreeNode* right = trimBST(root -> right, low, high);return right;}root -> left = trimBST(root -> left, low, high);root -> right = trimBST(root -> right, low, high);return root;}

//迭代法TreeNode* trimBST(TreeNode* root, int low, int high) {if (root == nullptr) return nullptr;//寻找合适的root,然后再进行修剪while (root != nullptr && (root -> val < low || root -> val > high)){if (root -> val < low) root = root -> right;else root = root -> left;}//修剪左子树TreeNode* cur = root;while (cur != nullptr){//左子树是否符合条件while (cur -> left != nullptr && cur -> left -> val < low){cur -> left = cur -> left -> right;}cur = cur -> left;}cur = root;while (cur != nullptr){//这块需要用while来判断,因为if的话只能判断一次,但是需要多次判断是否修剪这个节点while (cur -> right != nullptr && cur -> right -> val > high){cur -> right = cur -> right -> left;}cur = cur -> right;}return root;}

2025.4.22

108. 将有序数组转换为二叉搜索树

//递归法,每一段循环都采用左闭右闭的方式TreeNode* traversal(vector<int> nums, int l, int r){if (l > r) return nullptr;int mid = l + (r - l) / 2;TreeNode* root = new TreeNode(nums[mid]);root -> left = traversal(nums, l, mid - 1);root -> right = traversal(nums, mid + 1, r);return root;}TreeNode* sortedArrayToBST(vector<int>& nums) {TreeNode* root = traversal(nums, 0, nums.size() - 1);return root;}

TreeNode* sortedArrayToBST(vector<int>& nums) {if (nums.size() == 0) return nullptr;//定义三个队列queue<TreeNode*> nodeQue;queue<int> leftQue;queue<int> rightQue;//创建一个空节点,等找到了中间位置,再对空节点进行赋值TreeNode* node = new TreeNode();nodeQue.push(node);//记录当前nodeQue的空节点所需要存储的左右边界的值leftQue.push(0);rightQue.push(nums.size() - 1);while (!nodeQue.empty()){//将队列中的节点取出,并对其赋值TreeNode* curNode = nodeQue.front(); nodeQue.pop();int left = leftQue.front(); leftQue.pop();int right = rightQue.front(); rightQue.pop();int mid = left + (right - left) / 2;curNode -> val = nums[mid];//找到了根节点,然后为其添加左右节点if (left <= mid - 1){curNode -> left = new TreeNode();nodeQue.push(curNode -> left);leftQue.push(left);rightQue.push(mid - 1);}if (right >= mid + 1){curNode -> right = new TreeNode();nodeQue.push(curNode -> right);leftQue.push(mid + 1);rightQue.push(right);}}return node;}

2025.4.23

538. 把二叉搜索树转换为累加树

	//递归法int pre = 0;//需要采用逆向中序遍历,即右中左void traversal(TreeNode* node){if (node == nullptr) return;traversal(node -> right);pre += node -> val;node -> val = pre;traversal(node -> left);}TreeNode* convertBST(TreeNode* root) {traversal(root);return root;}

//迭代法
TreeNode* convertBST(TreeNode* root) {stack<TreeNode*> stk;int pre = 0;if (root != nullptr) stk.push(root);while (!stk.empty()){TreeNode* node = stk.top();stk.pop();if (node != nullptr){if (node -> left) stk.push(node -> left);stk.push(node);stk.push(nullptr);if (node -> right) stk.push(node -> right);}else{node = stk.top();stk.pop();pre += node -> val;node -> val = pre;}}return root;}

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

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

相关文章

Git ——提交至github，Vercel拉取，更新不了项目的问题解决

Git ——提交至github，Vercel拉取，更新不了项目的问题解决

首先因为github上有个错误 1 failing check Vercel - No GitHub account was found matching the commit author email address 发现好像是vercel拉取不了项目&#xff0c;vercel登录的邮箱与我此次提交更改的邮箱不匹配&#xff0c;查看Git的user确实如此&#xff08;之前的…
阅读更多...
Vue3项目中 npm 依赖安装 --save 与 --save-dev 的区别解析

Vue3项目中 npm 依赖安装 --save 与 --save-dev 的区别解析

这两个命令的区别如下&#xff1a; bash npm install --save types/crypto-js # 安装到 dependencies&#xff08;生产依赖&#xff09; npm install --save-dev types/crypto-js # 安装到 devDependencies&#xff08;开发依赖&#xff09; 核心区别 依赖分类不同…
阅读更多...
品牌如何通过朝日新闻出海日本？——某企业日本媒体发稿实战

品牌如何通过朝日新闻出海日本？——某企业日本媒体发稿实战

文 | 言同数字亚太传播实验室 一、日本市场的隐形门槛&#xff1a;中国品牌的三大痛点 案例背景&#xff1a; 某中国灵芝保健品企业&#xff08;代号"ForestLife"&#xff09;&#xff0c;产品虽获中国/欧盟有机认证&#xff0c;但在日本市场面临&#xff1a; 认知…
阅读更多...
鸿蒙-试一下属性字符串:除了Span之外，如何在同一个Text组件中展示不同样式的文字

鸿蒙-试一下属性字符串:除了Span之外，如何在同一个Text组件中展示不同样式的文字

文章目录 前言简介有哪些类型拉出来溜溜Text SpanStyledString其他CustomSpan先看一下构造函数onMeasure(measureInfo: CustomSpanMeasureInfo): CustomSpanMetricsonDraw(context: DrawContext, drawInfo: CustomSpanDrawInfo) 遗留问题 前言 在开发中&#xff0c;经常会遇到…
阅读更多...
Nginx 安装与配置全流程指南（2025 最新版）

Nginx 安装与配置全流程指南（2025 最新版）

一、环境准备与依赖安装 1.1 系统要求 操作系统&#xff1a;支持主流 Linux 发行版&#xff08;Ubuntu 20.04/CentOS 7/Debian 10&#xff09;硬件配置&#xff1a;内存 ≥512MB&#xff0c;磁盘 ≥10GB 可用空间&#xff08;建议使用 SSD&#xff09;网络要求&#xff1a;开…
阅读更多...
【LeetCode 热题 100】滑动窗口最大值 / 最小覆盖子串 / 轮转数组 / 缺失的第一个正数

【LeetCode 热题 100】滑动窗口最大值 / 最小覆盖子串 / 轮转数组 / 缺失的第一个正数

⭐️个人主页&#xff1a;小羊 ⭐️所属专栏&#xff1a;LeetCode 热题 100 很荣幸您能阅读我的文章&#xff0c;诚请评论指点&#xff0c;欢迎欢迎 ~ 目录 子串和为 K 的子数组滑动窗口最大值最小覆盖子串 普通数组最大子数组和合并区间轮转数组除自身以外数组的乘积缺失的…
阅读更多...
golang的cgo的一点小心得

golang的cgo的一点小心得

最后有个项目需要涉及到cgo&#xff0c;在这块以前用的不多&#xff0c; 这次略微用得深入了一点&#xff0c;记下来几点以备以后使用 本质上cgo去用的时候就是遵守一些ABI而已&#xff0c;总体而言&#xff0c;尽量避免复杂结构的来回传递。1 对于变长参数&#xff0c;只有…
阅读更多...
异构网络环境下的切换策略研究

异构网络环境下的切换策略研究

移动互联网应用快速崛起，现有的无线接入技术有，无线局域网（Wireless Local Area NetWork，WLAN），移动蜂窝网络（4G,5G），无线广域网（Wireless Wide Area Network，WWAL）以及卫星通信网络等。多接入技术方便用户通信，还符合多业务场景。这种多无线接入技术共存的网络环…
阅读更多...
人工智能赋能美妆零售数字化转型：基于开源AI大模型的S2B2C商城系统构建

人工智能赋能美妆零售数字化转型：基于开源AI大模型的S2B2C商城系统构建

摘要 在消费升级背景下&#xff0c;美妆行业正经历从传统卖场向智能体验空间的转型。本文以"未来商店"为研究对象&#xff0c;探讨开源AI大模型与S2B2C商城系统的协同效应&#xff0c;揭示人工智能技术如何重构"人-货-场"关系。通过实证研究发现&#xff…
阅读更多...
计算机视觉中的正则化：从理论到实践的全面解析

计算机视觉中的正则化：从理论到实践的全面解析

&#x1f31f; 计算机视觉中的正则化&#xff1a;从理论到实践的全面解析&#x1f31f; 大家好&#xff01;今天要和大家分享的是在计算机视觉&#xff08;CV&#xff09;领域中非常重要的一个概念——正则化&#xff08;Regularization&#xff09;。无论你是刚开始接触深度学…
阅读更多...
Linux字符设备驱动开发的详细步骤

Linux字符设备驱动开发的详细步骤

1. 确定主设备号​​ ​​手动指定​​&#xff1a;明确设备号时&#xff0c;使用register_chrdev_region()静态申请&#xff08;需确保未被占用&#xff09;。​​动态分配​​&#xff1a;通过alloc_chrdev_region()由内核自动分配主设备号&#xff08;更灵活&#xff0c;推…
阅读更多...
软件工程效率优化：一个分层解耦与熵减驱动的系统框架

软件工程效率优化：一个分层解耦与熵减驱动的系统框架

软件工程效率优化&#xff1a;一个分层解耦与熵减驱动的系统框架** 摘要 (Abstract) 本报告构建了一个全面、深入、分层的软件工程效率优化框架&#xff0c;旨在超越简单的技术罗列&#xff0c;从根本的价值驱动和熵减原理出发&#xff0c;系统性地探讨提升效率的策略与实践。…
阅读更多...
【Docker游戏】使用Docker部署vue-XiuXianGame文字修仙小游戏

【Docker游戏】使用Docker部署vue-XiuXianGame文字修仙小游戏

【Docker游戏】使用Docker部署vue-XiuXianGame文字修仙小游戏 一、vue-XiuXianGame介绍1.1 vue-XiuXianGame简介1.2 主要特点 二、本次实践规划2.1 本地环境规划2.2 本次实践介绍 三、本地环境检查3.1 检查Docker服务状态3.2 检查Docker版本3.3 检查docker compose 版本 四、拉…
阅读更多...
用 LangChain 手搓 RAG 系统：从原理到实战

用 LangChain 手搓 RAG 系统：从原理到实战

一、RAG 系统简介 在当今信息爆炸的时代&#xff0c;如何高效地从海量数据中获取有价值的信息并生成准确、自然的回答&#xff0c;成为了人工智能领域的重要课题。检索增强生成&#xff08;Retrieval-Augmented Generation&#xff0c;RAG&#xff09;系统应运而生&#xff0c;…
阅读更多...
SpringBoot集成LiteFlow实现轻量级工作流引擎

SpringBoot集成LiteFlow实现轻量级工作流引擎

LiteFlow 是一款专注于逻辑驱动流程编排的轻量级框架&#xff0c;它以组件化方式快速构建和执行业务流程&#xff0c;有效解耦复杂业务逻辑。通过支持热加载规则配置&#xff0c;开发者能够即时调整流程步骤&#xff0c;将复杂的业务如价格计算、下单流程等拆分为独立且可复用的…
阅读更多...
38 python random

38 python random

在实际中，我们常常会用到随机的概念，比如 模拟抽奖活动（如：月度优秀员工抽奖）生成测试数据（如：随机考勤时间、随机销售额）打乱数据顺序（如：随机分配任务到人）Python 的random模块就像你的 "随机事件生成器"，帮你轻松创建各种随机数据 一、基础操作：从随…
阅读更多...
附赠二张图，阐述我对大模型的生态发展、技术架构认识。

附赠二张图，阐述我对大模型的生态发展、技术架构认识。

文章精炼&#xff0c;用两张图说明大模型发展业态方向&#xff0c;以及大模型主体技术架构。&#xff08;目前还需要进一步验证我的Thought && ideas&#xff0c;等待机会吧.........&#xff09; 图一&#xff1a;探究大模型三个层次应用方向&#xff0c;浅层次入门简…
阅读更多...
2025上海车展 | 移远通信全栈车载智能解决方案重磅亮相，重构“全域智能”出行新范式

2025上海车展 | 移远通信全栈车载智能解决方案重磅亮相，重构“全域智能”出行新范式

2025年4月23日至5月2日&#xff0c;第二十一届上海国际汽车工业展览会在国家会展中心&#xff08;上海&#xff09;盛大启幕。作为车载智能解决方案领域的领军企业&#xff0c;移远通信以“全域智能 驭见未来”为主题&#xff0c;携丰富的车载解决方案及客户终端惊艳亮相8.2馆8…
阅读更多...
告别 “幻觉” 回答：RAG 中知识库与生成模型的 7 种对齐策略

告别 “幻觉” 回答：RAG 中知识库与生成模型的 7 种对齐策略

一、引言 大语言模型&#xff08;LLM&#xff09;在文本生成领域展现出惊人能力&#xff0c;但 “幻觉” 问题&#xff08;生成虚构或偏离事实的内容&#xff09;始终是落地应用的核心挑战。检索增强生成&#xff08;RAG&#xff09;通过将外部知识库与 LLM 结合&#xff0c;形…
阅读更多...
项目笔记2：post请求是什么，还有什么请求

项目笔记2：post请求是什么，还有什么请求

在 HTTP&#xff08;超文本传输协议&#xff09;中&#xff0c;请求方法用于向服务器表明客户端想要执行的操作。POST 请求是其中一种常见的请求方法&#xff0c;此外还有 GET、PUT、DELETE 等多种请求方法&#xff0c;下面为你详细介绍&#xff1a; POST 请求 定义&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023