【算法练习】leetcode算法题合集之二叉树篇

递归遍历基础篇

前序遍历,中序遍历,后序遍历是根据处理根节点的位置来命名的。

树的处理大多用到了递归,递归需要知道终止条件。

前序遍历(中左右)

144.二叉树的前序遍历

中左右,先处理根节点,再处理左子树,再处理右子树

class Solution {public List<Integer> preorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();preOrder(res, root);return res;}private void preOrder(List<Integer> res, TreeNode root) {if(root==null){return;}res.add(root.val);preOrder(res, root.left);preOrder(res, root.right);}
}

非递归版实现前序遍历

使用栈,当前节点处理完,先塞入右节点(后处理),再塞入左节点。

class Solution {public List<Integer> preorderTraversal(TreeNode root) {Stack<TreeNode> stack = new Stack<>();List<Integer> res = new ArrayList<>();if (root == null) {return res;}//右左stack.add(root);while (!stack.isEmpty()) {TreeNode pop = stack.pop();res.add(pop.val);if (pop.right != null) {stack.push(pop.right);}if (pop.left != null) {stack.push(pop.left);}}return res;}
}

中序遍历(左中右)

94.二叉树的中序遍历

递归方式

class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();inOrder(res, root);return res;}private void inOrder(List<Integer> res, TreeNode root) {if (root == null) {return;}inOrder(res, root.left);res.add(root.val);inOrder(res, root.right);}
}

非递归,左中右,先找到最左节点,处理当前节点,处理右节点。把最左边的节点都压入栈中。

class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();if (root == null) {return res;}Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while (cur != null || !stack.isEmpty()) {if (cur != null) {stack.push(cur);cur = cur.left;} else {TreeNode pop = stack.pop();res.add(pop.val);cur = pop.right;}}return res;}

后序遍历(左右中)

145.二叉树的后序遍历

递归方式

class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();postOrder(res, root);return res;}public void postOrder(List<Integer> res, TreeNode root) {if (root == null) {return;}postOrder(res,root.left);postOrder(res,root.right);res.add(root.val);}
}

非递归方式,左右中的逆序是中右左,处理可以参考前序遍历,最后进行倒序。

class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();if (root == null) {return res;}Stack<TreeNode> stack = new Stack<>();stack.push(root);while (!stack.isEmpty()) {TreeNode pop = stack.pop();res.add(pop.val);if(pop.left!=null){stack.push(pop.left);}if(pop.right!=null){stack.push(pop.right);}}Collections.reverse(res);return res;}}

层序遍历

LeetCode199.二叉树的右视图

LeetCode199.二叉树的右视图

获取当前行的最后一个元素。

class Solution_LC199 {public List<Integer> rightSideView(TreeNode root) {List<Integer> res = new ArrayList<>();if (root == null) {return res;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);while (!queue.isEmpty()) {int size = queue.size();while (size > 0) {size--;TreeNode node = queue.poll();if (size == 0) {res.add(node.val);}if (node.left != null) {queue.offer(node.left);}if (node.right != null) {queue.offer(node.right);}}}return res;}
}

LeetCode103.二叉树的锯齿形层序遍历

LeetCode103.二叉树的锯齿形层序遍历

对树进行判空

获取当前行的元素,需要获取队列的大小。

class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> res = new ArrayList<>();if (root == null) {return res;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);int index = 0;while (!queue.isEmpty()) {index++;LinkedList<Integer> list = new LinkedList<>();int size = queue.size();while (size > 0) {size--;TreeNode node = queue.poll();if (index % 2 == 0) {list.addFirst(node.val);} else {list.addLast(node.val);}if (node.left != null) {queue.add(node.left);}if (node.right != null) {queue.add(node.right);}}res.add(list);}return res;}}

剑指 Offer II 044. 二叉树每层的最大值

剑指 Offer II 044. 二叉树每层的最大值

原理同上。

class Solution_JZ044 {public List<Integer> largestValues(TreeNode root) {List<Integer> res = new ArrayList<>();if (root == null) {return res;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);while (!queue.isEmpty()) {int size = queue.size();int max = Integer.MIN_VALUE;while (size > 0) {size--;TreeNode node = queue.poll();if (node.val > max) {max = node.val;}if (node.left != null) {queue.offer(node.left);}if (node.right != null) {queue.offer(node.right);}}res.add(max);}return res;}
}

Leetcode101. 对称二叉树

Leetcode101. 对称二叉树

递归

比较最左边和最右边的元素。

class Solution {public boolean isSymmetric(TreeNode root) {if (root == null) {return true;}return dfs(root.left, root.right);}private boolean dfs(TreeNode left, TreeNode right) {if (left == null && right == null) {return true;}if (left == null || right == null) {return false;}if (left.val != right.val) {return false;}return dfs(left.left, right.right) && dfs(right.left, left.right);}
}

使用队列

class Solution {public boolean isSymmetric(TreeNode root) {if (root == null || (root.left == null && root.right == null)) {return true;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root.left);queue.offer(root.right);while (!queue.isEmpty()) {TreeNode left = queue.poll();TreeNode right = queue.poll();if (left == null && right == null) {continue;}if (left == null || right == null) {return false;}if (left.val != right.val) {return false;}queue.offer(left.left);queue.offer(right.right);queue.offer(right.left);queue.offer(left.right);}return true;}
}

前序遍历

LeetCode257.二叉树的所有路径

LeetCode257: 二叉树的所有路径

结束条件:该节点是叶子节点,结果集添加path

如何添加连接字符->

class Solution {List<String> res = new ArrayList<>();public List<String> binaryTreePaths(TreeNode root) {dfs(root, "");return res;}private void dfs(TreeNode root, String s) {if (root == null) {return;}s = s + root.val;if (root.left == null && root.right == null) {res.add(s);}else {dfs(root.left, s + "->");dfs(root.right, s + "->");}}
}

LeetCode129.求根到叶子节点数字之和

LeetCode 129.求根到叶子节点数字之和

按照上题的思路来,先把结果添加到集合里面。

class Solution {List<Integer> res = new ArrayList<>();public int sumNumbers(TreeNode root) {if (root == null) {return 0;}dfs(root, 0);int sum = 0;for (int i = 0; i < res.size(); i++) {sum += res.get(i);}return sum;}private void dfs(TreeNode root, int num) {if (root == null) {return;}num = num * 10 + root.val;if (root.left == null && root.right == null) {res.add(num);} else {dfs(root.left, num);dfs(root.right, num);}}
}

递归,当前节点的结果等于左子树操作+右子树操作

class Solution {List<Integer> res = new ArrayList<>();public int sumNumbers(TreeNode root) {if (root == null) {return 0;}return dfs2(root, 0);}private int dfs2(TreeNode root, int pre) {if (root == null) {return 0;}int sum = pre * 10 + root.val;if (root.left == null && root.right == null) {return sum;}return dfs2(root.right, sum) + dfs2(root.left, sum);}
}

LeetCode112.路径总和

112. 路径总和

不断累加值,判断是否和目标值相等

class Solution {public boolean hasPathSum(TreeNode root, int targetSum) {return dfs(root, targetSum, 0);}private boolean dfs(TreeNode root, int targetSum, int pre) {if (root == null) {return false;}if (root.left == null && root.right == null) {return pre + root.val == targetSum;} else {return dfs(root.left, targetSum, pre + root.val) || dfs(root.right, targetSum, pre + root.val);}}
}

更新目标值

class Solution {public boolean hasPathSum(TreeNode root, int targetSum) {if (root == null) {return false;}if (root.left == null && root.right == null) {return targetSum == root.val;}return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);}
}

LeetCode113.路径总和II

113. 路径总和 II

用队列记录当前路径下的元素,方便回退。

class Solution {List<List<Integer>> res = new LinkedList<>();LinkedList<Integer> queue = new LinkedList<>();public List<List<Integer>> pathSum(TreeNode root, int targetSum) {dfs(root,targetSum );return res;}private void dfs(TreeNode root, int targetSum) {if (root == null) {return;}targetSum -= root.val;queue.offer(root.val);if (root.left == null && root.right == null && targetSum == 0) {res.add(new ArrayList<>(queue));} else {dfs(root.left,  targetSum);dfs(root.right,  targetSum);}queue.pollLast();}
}

LeetCode437.路径总和 III(**)

LeetCode437. 路径总和 III

定义一个以某节点为开始节点获取路径总和为targetSum的方法。

不一定是叶子节点

用long代替int,因为有测试用例减溢出。

class Solution {public int pathSum(TreeNode root, int targetSum) {if (root == null) {return 0;}int res = rootSum(root, targetSum);return res + pathSum(root.left, targetSum) + pathSum(root.right, targetSum);}private int rootSum(TreeNode root, long targetSum) {int ret = 0;if (root == null) {return 0;}if (targetSum == root.val) {ret++;}return ret + rootSum(root.left, targetSum - root.val) + rootSum(root.right, targetSum - root.val);}
}

中序遍历

LeetCode98.验证二叉搜索树

LeetCode98.验证二叉搜索树

左子树上的节点都小于根节点,右子树上的值都大于根节点。

递归。

class Solution {public boolean isValidBST(TreeNode root) {return isValidBST(root, Long.MAX_VALUE, Long.MIN_VALUE);}private boolean isValidBST(TreeNode root, long maxValue, long minValue) {if (root == null) {return true;}if (root.val >= maxValue || root.val <= minValue) {return false;}return isValidBST(root.left, root.val, minValue) && isValidBST(root.right, maxValue, root.val);}
}

中序遍历

中序遍历 ,先左再中后右,左<中<右

比较数组是否有序,用tmp来缓存最小元素。

class Solution {public boolean isValidBST(TreeNode root) {Stack<TreeNode> stack = new Stack<>();long tmp = Long.MIN_VALUE;TreeNode cur = root;while (!stack.isEmpty() || cur != null) {if (cur != null) {stack.push(cur);cur = cur.left;}else {cur = stack.pop();if (cur.val <= tmp) {return false;}tmp = cur.val;cur = cur.right;}}return true;}
}

剑指 Offer 54. 二叉搜索树的第k大节点

剑指 Offer 54. 二叉搜索树的第k大节点.

第n大,就是数组中第n-k个元素。第2大的元素逆序在索引1的位置。

右中左,即中序遍历的数组的倒序。

class Solution_LCR174 {int res;int index = 0;public int findTargetNode(TreeNode root, int cnt) {dfs(root, cnt);return res;}private void dfs(TreeNode root, int cnt) {if (root == null) {return;}dfs(root.right, cnt);index++;if (index == cnt) {res = root.val;}dfs(root.left, cnt);}
}

Leetcode230. 二叉搜索树中第K小的元素

Leetcode230. 二叉搜索树中第K小的元素

同上,不需要倒序,更简单

class Solution {int k;int res;int index = 0;public int kthSmallest(TreeNode root, int k) {this.k = k;dfs(root);return res;}private void dfs(TreeNode root) {if (root == null) {return;}dfs(root.left);index++;if (index == k) {res = root.val;}dfs(root.right);}
}

剑指offer36: 二叉搜索树与双向链表(*)

剑指offer36: 二叉搜索树与双向链表

pre节点是前节点,获取最左边的节点为pre节点。不断更新pre节点。

核心还是中序遍历。

class Solution {Node pre = null, head = null;public Node treeToDoublyList(Node root) {if (root == null) return root;dfs(root);head.left = pre;pre.right = head;return head;}void dfs(Node root) {if (root == null) {return;}dfs(root.left);if (pre != null) {pre.right = root;} else {head = root;}root.left = pre;pre = root;dfs(root.right);}
}

Leetcode.538. 把二叉搜索树转换为累加树(*)

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

理解题意,原先是二叉搜索树,当先不一定是二叉搜索树。当前节点为原有树的大于等于当前节点(当前节点和所有右子树节点)的和。

class Solution {int sum = 0;public TreeNode convertBST(TreeNode root) {if (root == null) {return null;}convertBST(root.right);sum += root.val;root.val = sum;convertBST(root.left);return root;}
}

后序遍历

Leetcode104. 二叉树的最大深度

Leetcode104. 二叉树的最大深度

方法一:递归(后续遍历,左右中)

方法二:层序遍历

class Solution {public int maxDepth(TreeNode root) {if (root == null) {return 0;} else {return Math.max(maxDepth(root.right), maxDepth(root.left)) + 1;}}
}

LeetCode226. 翻转二叉树

LeetCode226. 翻转二叉树

要暂存左边的树

class Solution {public TreeNode invertTree(TreeNode root) {if (root == null) {return null;}TreeNode left = invertTree(root.left);TreeNode right = invertTree(root.right);root.right = left;root.left = right;return root;}
}

Leetcode110. 判断是否是平衡二叉树

Leetcode110. 判断是否平衡二叉树

求深度的扩展

class Solution {public boolean isBalanced(TreeNode root) {if (root == null) {return true;}return Math.abs(getDepth(root.left) - getDepth(root.right)) <= 1 & isBalanced(root.left)&& isBalanced(root.right);}private int getDepth(TreeNode root) {if (root == null) {return 0;}return 1 + Math.max(getDepth(root.right), getDepth(root.left));}
}

LeetCode543.二叉树的直径

LeetCode543.二叉树的直径

结果最大的数据不一定是根节点。

每一个节点的对应的直径等于左子树的深度+右子树的深度。

class Solution {int ans;public int diameterOfBinaryTree(TreeNode root) {if (root == null) {return 0;}depth(root);return ans;}private int depth(TreeNode root) {if (root == null) {return 0;}int left = depth(root.left);int right = depth(root.right);ans = Math.max(ans, right + left);return 1 + Math.max(left, right);}
}

LeetCode124.二叉树中的最大路径和

LeetCode124.二叉树中的最大路径和

计算以某节点为起点,最长的路径。路径和=左最大路径+右最大路径+当前节点的值。

如果该路径大于0,则选;否则不选。

class Solution {int ans = Integer.MIN_VALUE;public int maxPathSum(TreeNode root) {maxGain(root);return ans;}public int maxGain(TreeNode node) {if (node == null) {return 0;}int left = Math.max(maxGain(node.left), 0);int right = Math.max(maxGain(node.right), 0);ans = Math.max(ans, node.val + left + right);return node.val + Math.max(left, right);}
}

Leetcode236. 二叉树的最近公共祖先(**)

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

左子树能找到,两个节点都在左边;左右子树都找到,返回root;左右子树都找不到,返回

class Solution {public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if (root == null || p == root || q == root) {return root;}TreeNode leftNode = lowestCommonAncestor(root.left, p, q);TreeNode rightNode = lowestCommonAncestor(root.right, p, q);if (leftNode == null && rightNode == null) {return null;}if (leftNode == null) {return rightNode;}if (rightNode == null) {return leftNode;}return root;}
}

二叉搜索树

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

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

遍历树的元素

class Solution {public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {while (true) {if (root.val > p.val && root.val > q.val) {root = root.left;} else if (root.val < p.val && root.val < q.val) {root = root.right;} else {break;}}return root;}
}

剑指offer33: 验证二叉搜索树的后序遍历序列

验证二叉搜索树的后序遍历序列

后续遍历是左右中的结构,最后一个元素是root

序列中第一个元素大于root元素,该元素及以后是右子树的序列。

最后一个元素是根元素,不是右子树的一部分。

class Solution {public boolean verifyTreeOrder(int[] postorder) {// 左右中return dfs(postorder, 0, postorder.length - 1);}private boolean dfs(int[] postorder, int left, int right) {if (left >= right) {return true;}int tmp = left;int root = postorder[right];while (tmp < right && postorder[tmp] < root) {tmp++;}int mid = tmp;while (tmp < right) {if (postorder[tmp] < root) {return false;}tmp++;}return dfs(postorder, left, mid - 1) && dfs(postorder, mid, right - 1);}
}

二叉树的修改构造

LeetCode105.从前序和中序遍历构造二叉树

LeetCode105.从前序和中序遍历构造二叉树

前序 中左右 中序 左中右

分割中序遍历的序列,获取到左子树的长度和右子树的长度。

对数组的操作,要么是拷贝数组,要么是指定索引。

class Solution {Map<Integer, Integer> map = new HashMap<>();public TreeNode buildTree(int[] preorder, int[] inorder) {for (int i = 0; i < inorder.length; i++) {map.put(inorder[i], i);}return buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);}private TreeNode buildTree(int[] preorder, int preLeft, int preRight, int[] inorder, int inLeft, int inRight) {if (preRight < preLeft || inRight < inLeft) {return null;}int rootIndex = map.get(preorder[preLeft]);TreeNode root = new TreeNode(preorder[preLeft]);int leftLength = rootIndex - inLeft;root.left = buildTree(preorder, preLeft + 1, preLeft + leftLength, inorder, inLeft, rootIndex);root.right = buildTree(preorder, preLeft + leftLength + 1, preRight, inorder, rootIndex + 1, inRight);return root;}
}

Leetcode 297.二叉树的序列化与反序列化

Leetcode 297.二叉树的序列化与反序列化

使用先序遍历来构成数组,数组转换成树。

public class Codec {public String serialize(TreeNode root) {return rserialize(root, "");}private String rserialize(TreeNode root, String s) {if (root == null) {s += "NONE,";} else {s += root.val + ",";s = rserialize(root.left, s);s = rserialize(root.right, s);}return s;}// Decodes your encoded data to tree.public TreeNode deserialize(String data) {String[] dataList = data.split(",");return rdeserialize(new ArrayList(Arrays.asList(dataList)));}private TreeNode rdeserialize(List<String> dataList) {if (dataList.get(0).equals("NONE")) {dataList.remove(0);return null;}TreeNode root = new TreeNode(Integer.valueOf(dataList.get(0)));dataList.remove(0);root.left = rdeserialize(dataList);root.right = rdeserialize(dataList);return root;}
}

二叉树的递归思维

LeetCode572.另一个树的子树

LeetCode572.另一个树的子树

简化成两棵树是否相等

class Solution {public boolean isSubtree(TreeNode root, TreeNode subRoot) {if (root == null) {return false;}return isSameTree(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);}public boolean isSameTree(TreeNode s, TreeNode t) {if (s == null && t == null) {return true;}if (s == null || t == null || s.val != t.val) {return false;}return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);}
}

其他

LeetCode114. 二叉树展开为链表

比较简单的方法就是先序遍历元素。

class Solution {List<TreeNode> list = new ArrayList<>();public void flatten(TreeNode root) {dfs(root);for (int i = 1; i < list.size(); i++) {TreeNode prev = list.get(i - 1), cur = list.get(i);prev.left = null;prev.right = cur;}}private void dfs(TreeNode root) {if (root == null) {return;}list.add(root);dfs(root.left);dfs(root.right);}
}

把右节点放在左节点的最右节点的右边,把左节点放在右边,这样顺序是正确的。

class Solution {public void flatten(TreeNode root) {TreeNode cur = root;while (cur != null) {TreeNode left = cur.left;if (left != null) {TreeNode tmp = left;while (tmp.right != null) {tmp = tmp.right;}tmp.right = cur.right;cur.left = null;cur.right = left;}cur = cur.right;}}
}

在这里插入图片描述

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

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

相关文章

Java面试高招:程序员如何在面试中脱颖而出

Java面试高招&#xff1a;程序员如何在面试中脱颖而出 《Java面试高招&#xff1a;程序员如何在面试中脱颖而出》摘要引言面试经历面试失败的反思 面试技巧侦探式的问题解决无敌铁金刚的坚定决心 参考资料 博主 默语带您 Go to New World. ✍ 个人主页—— 默语 的博客&#x1…

4.5 A TILED MATRIX MULTIPLICATION KERNEL

我们现在准备展示一个tiled矩阵乘法内核&#xff0c;该内核使用共享内存来减少对全局内存的流量。图中4.16显示的内核。实施图4.15.中所示的阶段。在图4.16中&#xff0c;第1行和第2行声明Mds和Nds为共享内存变量。回想一下&#xff0c;共享内存变量的范围是一个块。因此&#…

Redis原理篇(Dict的收缩扩容机制和渐进式rehash)

Dict&#xff08;即字典&#xff09; Redis是一种键值型数据库&#xff0c;其中键与值的映射关系就是Dict实现的。 Dict通过三部分组成&#xff1a;哈希表&#xff08;DictHashTable&#xff09;&#xff0c;哈希节点(DictEntry)&#xff0c;字典&#xff08;Dict&#xff09…

书生·浦语大模型全链路开源体系 学习笔记 第二课

基础作业&#xff1a; 使用 InternLM-Chat-7B 模型生成 300 字的小故事&#xff08;需截图&#xff09;。熟悉 hugging face 下载功能&#xff0c;使用 huggingface_hub python 包&#xff0c;下载 InternLM-20B 的 config.json 文件到本地&#xff08;需截图下载过程&#xf…

tiktok云手机有用吗?用哪个好?

很多做独立站的跨境卖家都会搭配一些社媒平台给自己引流带货&#xff0c;比如说目前很火的TikTok&#xff0c;这也是目前比较有效的一种引流方式。本文将介绍tiktok运营方法以及如何用tiktok云手机规避运营风险。 TikTok是个不错的风口&#xff0c;不过我们在国内想要运营好Tik…

数环通12月产品更新:新增数据表相关功能、优化编辑器,15+应用进行更新

为了满足用户不断增长的需求&#xff0c;我们持续努力提升产品的功能和性能&#xff0c;以更好地支持用户的工作。 数环通12月的最新产品更新已经正式发布&#xff0c;带来了一系列强大的功能&#xff0c;以提升您的工作效率和系统的可靠性。 更新快速预览 新增&优化功能&a…

软考-软件设计师 知识点整理(一篇就过了 建议收藏)

文章目录 一 计算机组成CPU寻址方式校验码奇偶校验码&#xff08;只能检一位错&#xff0c;并且不能纠错&#xff09;循环冗余校验码CRC&#xff08;只能检错&#xff0c;不能纠错&#xff09;海明码 计算机体系结构分类Flynn分类法&#xff08;理论存在&#xff1a;多指令单数…

Java LeetCode篇-二叉搜索树经典解法(实现:二叉搜索树的最近公共祖先、根据前序遍历建树等)

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 判断合法 1.1 使用遍历方式实现验证二叉搜索树 1.2 使用递归方式实现验证二叉搜索树 2.0 求范围和 2.1 使用非递归实现二叉搜索树的范围和 2.2 使用递归方式实现…

腾讯云com域名注册1元一年,非常可以!

腾讯云com域名注册优惠价格1元首年&#xff0c;条件是企业新用户&#xff0c;个人新用户注册com域名是33元首年&#xff0c;第二年续费价格85元一年。活动 txybk.com/go/domain-sales 活动打开如下图&#xff1a; 腾讯云com域名注册优惠价格 腾讯云com域名注册原价是85元一年&a…

已解决 ValueError: Setting an array element with a sequence. 问题

博主猫头虎的技术世界 &#x1f31f; 欢迎来到猫头虎的博客 — 探索技术的无限可能&#xff01; 专栏链接&#xff1a; &#x1f517; 精选专栏&#xff1a; 《面试题大全》 — 面试准备的宝典&#xff01;《IDEA开发秘籍》 — 提升你的IDEA技能&#xff01;《100天精通Golang》…

C++类与对象基础(6)

(注&#xff1a;本篇文章介绍部分内容时&#xff0c;需要用到上盘文章中日期类的代码&#xff0c;文章链接如下&#xff1a;C类与对象基础(5)——日期类的实现-CSDN博客​​​​​​&#xff09; 目录 1. 运算符重载的相关补充&#xff1a; 1.1流运算符重载出现的问题&#x…

李沐-《动手学深度学习》--03-注意力机制

一、注意力机制 1 . 注意力提示 1&#xff09;框架 **随意&#xff1a;**跟随自己的想法的&#xff0c;自主的想法&#xff0c;例如query **不随意&#xff1a;**没有任何偏向的选择&#xff0c;例如 Keys 如何得到 k v q 2&#xff09;Nadaraya-Watson核回归 就是一个so…

《2024 AIGC 应用层十大趋势白皮书》:近屿智能OJAC带您一起探索AI未来

Look&#xff01;&#x1f440;我们的大模型商业化落地产品&#x1f4d6;更多AI资讯请&#x1f449;&#x1f3fe;关注Free三天集训营助教在线为您火热答疑&#x1f469;&#x1f3fc;‍&#x1f3eb; 近日国际知名咨询机构IDC发布《2024 AIGC 应用层十大趋势白皮书》的发布&am…

Spring 动态数据源事务处理

在一般的 Spring 应用中,如果底层数据库访问采用的是 MyBatis,那么在大多数情况下,只使用一个单独的数据源,Spring 的事务管理在大多数情况下都是有效的。然而,在一些复杂的业务场景下,如需要在某一时刻访问不同的数据库,由于 Spring 对于事务管理实现的方式,可能不能达…

二叉树OJ练习(二)

1. 二叉树的最近公共祖先 题目描述&#xff1a; ​ 题解: 1.p或者q其中一个等于root&#xff0c;那么root就是最进公共祖先 2.p和q分布在root的左右两侧&#xff0c;那么root就是最进公共祖先 3.p和q在root的同一侧&#xff0c;就是要遍历这棵树&#xff0c;遇到p或者q返回 ​…

一款好的葡萄酒关键在哪里?

除了易于种植&#xff0c;赤霞珠还因其独特的口感、难以置信的味道和质量而闻名。这种葡萄主要用于中高端干红葡萄酒&#xff0c;通常表现出成熟的黑色水果味道&#xff0c;带有辛辣和泥土气息。 在橡木桶中陈酿后&#xff0c;赤霞珠表现极佳。随着葡萄酒的陈年&#xff0c;橡木…

【金猿人物展】数元灵科技CEO朱亚东:何以数智化

‍ 朱亚东 本文由数元灵科技CEO朱亚东撰写并投递参与“数据猿年度金猿策划活动——2023大数据产业年度趋势人物榜单及奖项”评选。 大数据产业创新服务媒体 ——聚焦数据 改变商业 在大数据经济的高速发展下&#xff0c;数据已经成为第5生产要素。打造以数据驱动为中心的标准化…

腾讯云免费服务器申请1个月攻略,亲测可行教程

腾讯云免费服务器申请入口 https://curl.qcloud.com/FJhqoVDP 免费服务器可选轻量应用服务器和云服务器CVM&#xff0c;轻量配置可选2核2G3M、2核8G7M和4核8G12M&#xff0c;CVM云服务器可选2核2G3M和2核4G3M配置&#xff0c;腾讯云服务器网txyfwq.com分享2024年最新腾讯云免费…

NUXT3学习笔记

1.邂逅SPA、SSR 1.1 单页面应用程序 单页应用程序 (SPA) 全称是&#xff1a;Single-page application&#xff0c;SPA应用是在客户端呈现的&#xff08;术语称&#xff1a;CSR&#xff08;Client Side Render&#xff09;&#xff09; SPA的优点 只需加载一次 SPA应用程序只需…

(二)Explain使用与详解

explain中的列 sql语句: EXPLAIN SELECT * from user WHERE userId=1340; 执行结果: 1. id列 id列的编号是 select 的序列号,有几个 select 就有几个id,并且id的顺序是按 select 出现的顺序增长的。 id列越大执行优先级越高,id相同则从上往下执行,id为NULL最后执行…