数据结构练习题————(二叉树)——考前必备合集!
今天在牛客网和力扣上带来了数据结构中二叉树的进阶练习题
1.二叉搜索树与双向链表———二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com)
2.二叉树遍历————二叉树遍历_牛客题霸_牛客网 (nowcoder.com)
3.二叉树的层序遍历————102. 二叉树的层序遍历 - 力扣(LeetCode)
4.二叉树的层序遍历————107. 二叉树的层序遍历 II - 力扣(LeetCode)
5.两个节点的最近公共祖先————236. 二叉树的最近公共祖先 - 力扣(LeetCode)
6.根据二叉树创建字符串————606. 根据二叉树创建字符串 - 力扣(LeetCode)
7.从前序和中序遍历构造二叉树————105. 从前序与中序遍历序列构造二叉树 - 力扣(LeetCode)
8.从中序和后序遍历构造二叉树————106. 从中序与后序遍历序列构造二叉树 - 力扣(LeetCode)
9.非递归二叉树的前序遍历————144. 二叉树的前序遍历 - 力扣(LeetCode)
1,二叉搜索树与双向链表
描述
输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。如下图所示
数据范围:输入二叉树的节点数 0≤n≤10000≤n≤1000,二叉树中每个节点的值 0≤val≤10000≤val≤1000
要求:空间复杂度O(1)O(1)(即在原树上操作),时间复杂度 O(n)O(n)注意:
1.要求不能创建任何新的结点,只能调整树中结点指针的指向。当转化完成以后,树中节点的左指针需要指向前驱,树中节点的右指针需要指向后继
2.返回链表中的第一个节点的指针
3.函数返回的TreeNode,有左右指针,其实可以看成一个双向链表的数据结构4.你不用输出双向链表,程序会根据你的返回值自动打印输出
输入描述:
二叉树的根节点
返回值描述:
双向链表的其中一个头节点。
示例1
输入:
abc##de#g##f###复制输出:
c b e g d f a
思路:说实话这题我觉得挺难的,看解答才弄懂,我们要创建的链表的顺序就是二叉树中序遍历的顺序,所以我们用一个中序遍历的方法,在遍历过程中,记录我们前一个节点,让当前节点也前一个节点像链表一样连起来。
public class Solution {public TreeNode Convert(TreeNode pRootOfTree) {TreeNode a = inOrderTree(pRootOfTree);return a;}public static TreeNode head=null;public static TreeNode prev=null;public static TreeNode inOrderTree(TreeNode root){if(root==null){return null;}inOrderTree(root.left);if(prev==null){head = root;prev = root;}else{prev.right = root;root.left = prev;prev = root;}inOrderTree(root.right);return head;}
}
我们来走一遍,
刚开始,head和prev都为空,我们进行中序遍历,从节点10开始,向左递归,到节点6,向左递归,到节点4,向左递归,到null,返回,我们此时判断prev是否为空,为空,我们把head和prev都设立为当前节点4,我们向右递归,为空,返回,4,全递归完毕,整体返回,到6,6的左节点递归完毕,进行prev判断,不为空,prev的right指向当前节点,当前节点的left指向前一个节点,向右递归,到8节点,8节点向左递归,为空,返回,判断prev,不为空,我们prev已经记录下前一个节点了,让当前节点的left指向前一个节点,前一个节点的right指向下一个当前节点,我们就完成了两个节点的链接,8,向右递归,遇到null,返回,6整体返回,到10,接下来重复这个过程。
注意1一定是对前一个节点进行操作,如果提前对后一个节点进行操作,那么就会丢失,二叉树就找不到节点了。
2,二叉树遍历
描述
编一个程序,读入用户输入的一串先序遍历字符串,根据此字符串建立一个二叉树(以指针方式存储)。 例如如下的先序遍历字符串: ABC##DE#G##F### 其中“#”表示的是空格,空格字符代表空树。建立起此二叉树以后,再对二叉树进行中序遍历,输出遍历结果。
输入描述:
输入包括1行字符串,长度不超过100。
输出描述:
可能有多组测试数据,对于每组数据, 输出将输入字符串建立二叉树后中序遍历的序列,每个字符后面都有一个空格。 每个输出结果占一行。
示例1
输入:
abc##de#g##f###复制输出:
c b e g d f a
思路:这道题我们要遍历字符串,因为是用先序遍历的方法,所以我们遇到字母的时候就创建节点,##的时候就为空,再对我们创建好的二叉树进行中序遍历。
import java.util.Scanner;class TreeNode{char val;TreeNode left;TreeNode right;public TreeNode(char val){this.val = val;}
}
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {public static void main(String[] args) {Scanner in = new Scanner(System.in);while(in.hasNextLine()){String str = in.nextLine();TreeNode root = createTree(str);inorderTree(root);}}static int i = 0;public static TreeNode createTree(String str){TreeNode b = null;char a = str.charAt(i);if(a!='#'){b = new TreeNode(a);i++;b.left=createTree(str);b.right=createTree(str);}else{i++;return null;}return b;}public static void inorderTree(TreeNode root){if(root==null){return ;}inorderTree(root.left);System.out.print(root.val+" ");inorderTree(root.right);}
}
创建节点和中序遍历的方法就不说了,前几期都详细介绍了嗷,我们直接讲那个创建二叉树,还是刚才那样,一步一步来。
int i我们定义成为静态的因为我们递归的时候不希望他返回的时候没有进行操作,定义静态的就不受影响了,我们从字符串开始看,我们开始i为1,得到的第一个字符是a,a不等于#,我们创建节点A,i++,节点的左边我们开始递归,字符不为#,创建节点,i++,这个节点此时已经与A的左边连上了,我们继续向左递归,字符不为#,i++,创建节点c,与b的左边连上,再向左递归,遇到null,i++,返回null,此时来到c的左边,c向右递归,遇到井号,i++,返回null,返回到b,b向右递归............一直下去。
3,二叉树的层序遍历
给你二叉树的根节点
root
,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。示例 1:
输入:root = [3,9,20,null,null,15,7] 输出:[[3],[9,20],[15,7]]示例 2:
输入:root = [1] 输出:[[1]]示例 3:
输入:root = [] 输出:[]
思路:这题不难的,我们之前详细做过二叉树的层序遍历,我们只要用一个引用,和一个队列就OK了,但是这题不一样,他想让我们返回一个类似二维数组的链表
我们只需要之前层序遍历打印元素的时候,提前算出我们要放在每一层的元素个数,再把他们都放到小链表中,最后再放到大链表中。
class Solution {Queue<TreeNode> queue = new LinkedList<TreeNode>();List<List<Integer>> list1 = new LinkedList<>();public List<List<Integer>> levelOrder(TreeNode root) {if(root==null){return list1;}TreeNode cur = root;queue.offer(root);while(!queue.isEmpty()){List<Integer> list2 = new LinkedList<>();int sz = queue.size();for(int i=1;i<=sz;i++){cur = queue.poll();list2.add(cur.val);if(cur.left!=null){queue.offer(cur.left);}if(cur.right!=null){queue.offer(cur.right);}}list1.add(list2);}return list1;}
}
4,二叉树的层序遍历2
给你二叉树的根节点
root
,返回其节点值 自底向上的层序遍历 。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)示例 1:
输入:root = [3,9,20,null,null,15,7] 输出:[[15,7],[9,20],[3]]示例 2:
输入:root = [1] 输出:[[1]]示例 3:
输入:root = [] 输出:[]
思路:跟刚才的题基本一致,只需要改一个地方,我们已经实现了刚才的二维链表了,我们在每次实现小链表的思路不变,只需要在实现大链表的时候,实现的不是尾插,而是头插即可。
class Solution {Queue<TreeNode> queue = new LinkedList<>();List<List<Integer>> list1 = new ArrayList<>();public List<List<Integer>> levelOrderBottom(TreeNode root) {if(root==null){return list1;}TreeNode cur = null;queue.offer(root);while(!queue.isEmpty()){int sz = queue.size();List<Integer> list2 = new ArrayList<>();while(sz>0){cur = queue.poll();list2.add(cur.val);sz--;if(cur.left!=null){queue.offer(cur.left);}if(cur.right!=null){queue.offer(cur.right);}}list1.add(0,list2);}return list1;}
}
5,两个节点的最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 p、q,最近公共祖先表示为一个节点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
示例 1:
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出:3 解释:节点5
和节点1
的最近公共祖先是节点3 。
示例 2:
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出:5 解释:节点5
和节点4
的最近公共祖先是节点5 。
因为根据定义最近公共祖先节点可以为节点本身。示例 3:
输入:root = [1,2], p = 1, q = 2 输出:1
这道题我们可以使用两个方法,第一个就是传统的二叉树遍历,第二个方法就是找他们的交点,
第一种方法,思路:我们去遍历这个二叉树,从左树开始完了右树,我们可以分为4种情况。
p或者q就在树的根节点,此时根节点直接就是我们要找的祖先节点。
第二种情况就是p和q在左树和右树的两边,当二叉树从左到右全部递归完毕的时候,我们走到节点,此时判断leftNode和rightNode是否为空,如果不为空,说明当前节点已经是p,q节点的最近公共祖先了,我们只需一直返回它即可,这种情况,一定是根节点,
那这个只能判断根节点,那么这个图怎么弄呢
我们在5节点找到最近公共祖先,返回5节点,3节点左边接收到5节点,但是右边为null,无法输出,所以我们在最后两行判断了这种特殊情况,如果只有左节点或者只有有节点成功获得祖先节点的返回值,我们就输出获得的这个节点,因为我们知道,如果3的左边没有获得q节点,那么它一定是在左边且p节点的下边,因为题目说了一定有p,q节点的。
class Solution {public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if(root==null){return root;}if(root.val==p.val || root.val==q.val){return root;}TreeNode leftNode = lowestCommonAncestor(root.left,p,q);TreeNode rightNode = lowestCommonAncestor(root.right,p,q);if(leftNode!=null && rightNode!=null){return root;}if(leftNode!=null){return leftNode;}return rightNode;}
}
第二种方法,我们想象成两个链表相交的思路
我们遍历二叉树把p和q的长度放到对应的栈中
再让长的那个栈出一个元素,之后两个栈一起出最后剩的一个元素就是我们的最近公共祖先。
class Solution {Stack<TreeNode> stack1 = new Stack<>();Stack<TreeNode> stack2 = new Stack<>();public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if(root==null){return null;}getpath(root,p,stack1);getpath(root,q,stack2);if(stack1.size()>stack2.size()){Stack<TreeNode> tmp = new Stack<>();tmp = stack1;stack1 = stack2;stack2 = tmp;}while(stack2.size()-stack1.size()>0){stack2.pop();}while(stack1.peek().val != stack2.peek().val){stack1.pop();stack2.pop();}return stack2.pop();}public boolean getpath(TreeNode root,TreeNode p,Stack<TreeNode> stack){if(root==null){return false;}stack.push(root);if(root.val==p.val){return true;}boolean a = getpath(root.left,p,stack);if(a==true){return true;}boolean b = getpath(root.right,p,stack);if(b==true){return true;}stack.pop();return false;}
}
我们看着这个getpath代码走几次,就拿题目中的p=5,q=1, 和p=5,q=4。
我们找q节点
我们从节点3开始将节点3放入stack1中,向左递归,到5节点,将5放到stack1中,向左递归,到节点6,将节点6放到stack1中,向左递归,返回null,向右递归,返回null,将节点6移出stack中,返回5节点,5节点向右递归,到2节点,将2节点放入stack1中,向左递归,遇到节点7,将节点7放到stack中,向左递归,遇到null返回,向右递归,遇到null,返回,将7移出stack,返回到节点2,向右递归,遇到节点4,找到q节点了,返回true,到2节点,返回true,到5,返回true,到3的左边,返回true;找到q节点,p节点同理,当q=1的时候,左边没有一个true,全部都被移出了。
6,根据二叉树创建字符串
给你二叉树的根节点
root
,请你采用前序遍历的方式,将二叉树转化为一个由括号和整数组成的字符串,返回构造出的字符串。空节点使用一对空括号对
"()"
表示,转化后需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。示例 1:
输入:root = [1,2,3,4] 输出:"1(2(4))(3)" 解释:初步转化后得到 "1(2(4)())(3()())" ,但省略所有不必要的空括号对后,字符串应该是"1(2(4))(3)" 。示例 2:
输入:root = [1,2,3,null,4] 输出:"1(2()(4))(3)" 解释:和第一个示例类似,但是无法省略第一个空括号对,否则会破坏输入与输出一一映射的关系。
思路:这道题就不是很难了,我们观察每个输入输出的例子,对于每个节点有几个子节点就会在后面出现(对应节点),null也为(),所以的父亲节点都会在()的前面。
class Solution {public static StringBuilder sb;public String tree2str(TreeNode root) {sb = new StringBuilder("");createString(root);String str = sb.toString();return str;}public void createString(TreeNode root){if(root==null){return;}sb.append(root.val);if(root.left!=null){sb.append("(");createString(root.left);sb.append(")");}else{if(root.right==null){return;}else{sb.append("(");sb.append(")");}}if(root.right!=null){sb.append("(");createString(root.right);sb.append(")");}else{return;}}
}
这道题我们用子问题思路,关注每个节点,每次递归时,我们都先把当前节点拼接到字符串上,我们使用StringBuilder来拼接,而不是用string去+,因为在使用String+的时候会创建很多的对象,浪费很多的内存和时间,我们拼接好后判断当前节点左右子节点的情况,在对其进行操作。
7,前序遍历与中序遍历构造二叉树
给定两个整数数组
preorder
和inorder
,其中preorder
是二叉树的先序遍历,inorder
是同一棵树的中序遍历,请构造二叉树并返回其根节点。示例 1:
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] 输出: [3,9,20,null,null,15,7]示例 2:
输入: preorder = [-1], inorder = [-1] 输出: [-1]
思路:
我们是怎么通过先序遍历和中序遍历构建字符串的呢,我们先看前序遍历,因为前序遍历,每次都是先遇到节点,再向左,向右遍历。所以我们创建二叉树的时候也是按照前序遍历的顺序构建节点,接下来就要考虑节点的左右了,我们这时使用中序遍历,把中序遍历的头记为begin,尾记为end,我们先找跟节点,前序遍历的头,在中序遍历中找到前序遍历的头,就是我们的根节点,我们把它的下标记为index。
这时我们再分两边构建两树,左边的begin不变,end变味index-1,右边end不变,begin=index+1
继续递归。
此时左树的end已经小于begin,左树的递归就停止了,右树继续
右树的左子树递归完毕,begin>end,递归右子,
递归全部完毕。
class Solution {public TreeNode buildTree(int[] preorder, int[] inorder) {return buildTreeChild(preorder,inorder,0,inorder.length-1);}int i = 0;public TreeNode buildTreeChild(int[] preorder, int[] inorder, int begin, int end){if(begin>end){return null;}TreeNode root = new TreeNode(preorder[i]);int index = FindIndex(preorder,inorder,begin,end);i++;root.left = buildTreeChild(preorder,inorder,begin,index-1);root.right = buildTreeChild(preorder,inorder,index+1,end);return root;}public int FindIndex(int[] preorder,int[] inorder, int begin,int end){for(int j = begin;j<=end;j++){if(preorder[i]==inorder[j]){return j;}}return -1;}
}
8,从中序与后序遍历构建二叉树
给定两个整数数组
inorder
和postorder
,其中inorder
是二叉树的中序遍历,postorder
是同一棵树的后序遍历,请你构造并返回这颗 二叉树 。示例 1:
输入:inorder = [9,3,15,20,7], postorder = [9,15,7,20,3] 输出:[3,9,20,null,null,15,7]示例 2:
输入:inorder = [-1], postorder = [-1] 输出:[-1]
思路和刚才前序遍历加中序遍历构建二叉树一样。但是我们这次是从后序遍历最后一个下边往前遍历创建节点, 在每次递归时我们都是先创建右树,在左树。
class Solution {public int i;public TreeNode buildTree(int[] inorder, int[] postorder) {i = postorder.length-1;return buildTreeChild(inorder,postorder,0,inorder.length-1);}public TreeNode buildTreeChild(int[] inorder,int[] postorder,int begin,int end){if(begin>end){return null;}TreeNode root = new TreeNode(postorder[i]);int index = findIndex(inorder,postorder,begin,end);i--;root.right = buildTreeChild(inorder,postorder,index+1,end);root.left = buildTreeChild(inorder,postorder,begin,index-1);return root;}public int findIndex(int[] inorder,int[] postorder,int begin,int end){for(int j=begin;j<=end;j++){if(postorder[i]==inorder[j]){return j;}}return -1;}
}
9,非递归的二叉树的前序遍历
给你二叉树的根节点
root
,返回它节点值的 前序 遍历。示例 1:
输入:root = [1,null,2,3]
输出:[1,2,3]
解释:
示例 2:
输入:root = [1,2,3,4,5,null,8,null,null,6,7,9]
输出:[1,2,4,5,6,7,3,8,9]
解释:
示例 3:
输入:root = []
输出:[]
示例 4:
输入:root = [1]
输出:[1]
这题我们之前做过我们使用最基础的递归,我们可不可以用迭代做呢
既然是官方给的,那必须做了。
我们之前用队列实现过层序遍历,其实原理都一样,我们这次使用栈来完成前序遍历。
看这个图,我们把一放到栈中,再把栈中的第一个元素pop到cur中。
把cur右边的元素先放到栈,再放cur左边的栈。再出栈中的第一个元素,如此往复。
class Solution {Stack<TreeNode> stack1 = new Stack<>();List<Integer> list = new LinkedList<>();public List<Integer> preorderTraversal(TreeNode root) {if(root==null){return list;}TreeNode cur = null;stack1.push(root);while(!stack1.isEmpty()){cur = stack1.pop();if(cur==null){continue;}else{list.add(cur.val);stack1.push(cur.right);stack1.push(cur.left);}}return list;}
}
相关文章:

数据结构练习题————(二叉树)——考前必备合集!
今天在牛客网和力扣上带来了数据结构中二叉树的进阶练习题 1.二叉搜索树与双向链表———二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com) 2.二叉树遍历————二叉树遍历_牛客题霸_牛客网 (nowcoder.com) 3.二叉树的层序遍历————102. 二叉树的层序遍历 - 力扣&am…...
一天认识一个硬件之鼠标
今天来给大家分享一下鼠标的相关内容,先来分享一下什么是鼠标: 鼠标是一种计算机输入设备,用于控制屏幕上的光标移动和进行各种操作。它最早由道格拉斯恩格尔巴特在1963年发明,并在1968年12月9日制成了世界上第一个鼠标。介绍完了…...

Django 请求配置
http请求配置 请求流程 urls.py配置 from first_app import viewsurlpatterns [path(admin/, admin.site.urls),path(test/,views.first_test), ] views.py配置 from django.shortcuts import render,HttpResponse# Create your views here. def first_test(request):prin…...
轮播图组件更加完善版
依然是基于微博语法开发,使用时请注意标签替换 优化了滑动的效果,默认的索引,滑动距离等, 使用方式和以前一样没变,主要修改了组件内部 <template><wbx-view class"" style"width: 100vw;heig…...

cpu路、核、线程
路:主板插口实际插入的 CPU 个数,也可以理解为主板上支持的CPU的数量。每个CPU插槽可以插入一个物理处理器芯片。例如,一台服务器可能有2路或4路插槽,这意味着它最多可以安装2个或4个物理处理器。 核:单块 CPU 上面能…...
鸿蒙开发(NEXT/API 12)【硬件(注册出行业务事件监听)】车载系统
注册出行业务事件监听,用于接收业务发送事件的通知。 接口说明 接口名描述[on] (type: ‘smartMobilityEvent’, smartMobilityTypes: SmartMobilityType[],callback: Callback): void应用注册出行业务事件监听。 开发步骤 导入Car Kit模块。 import { smartMobi…...
安卓中有main函数吗?
在标准的Android应用程序开发中,并不直接使用类似于传统Java或C程序中的main函数入口点。Android应用程序是基于组件的架构,它依赖于几个关键组件来执行不同的任务,这些组件包括Activity、Service、Broadcast Receiver和Content Provider。 …...
js-17-对数组、对象进行浅拷贝和深拷贝
目录 数组一、浅拷贝1. 展开运算符...2. Array.prototype.slice() 二、深拷贝1. JSON方法2. 递归函数 对象一、浅拷贝1. Object.assign()2. 展开运算符... 二、深拷贝1. JSON方法2. 递归函数 自己总结的一些方法,可能有不到位的地方,欢迎指出 数组 一、…...
Ubuntu24.04中安装Electron
1. 安装Nodejs 使用代理服务从github下载并执行Nodejs安装脚本(假设代理服务器为192.168.2.150:10792) curl -x 192.168.2.150:10792 -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash #注意,Nodejs官网的安装命令少了下面这一行: …...
CPU中也应用到了缓存:CPU3层高速缓存,以及它的缓存一致性问题、MESI协议和Java的一些应用
为什么需要cpu高速缓存? 缓存,一般是为了用来协调两端的数据传输效率差(也可以归纳为性能差),提升响应速度。那么CPU的高速缓存是用来协调什么之间的速度差呢? CPU在处理一条指令的时候,会读写…...
如何使用开发者工具捕获鼠标右键点击事件
要使用浏览器的开发者工具捕获鼠标右键点击事件,请按照以下步骤操作: 打开开发者工具 在大多数浏览器中,您可以按 F12 键或右键单击页面并选择"检查"或"检查元素"。 切换到 Console 标签页 在开发者工具中,找到并点击 “Console” 标签。 添加事件监听器…...
【几何】个人练习-Leetcode-1453. Maximum Number of Darts Inside of a Circular Dartboard
题目链接:https://leetcode.cn/problems/maximum-number-of-darts-inside-of-a-circular-dartboard/description/ 题目大意:给出一系列点和一个圆的半径,(寻找一个圆心)求这个半径的圆最多能覆盖多少个点。 思路&…...

啤酒:从饮品到文化的演变
在人类饮品的长河中,啤酒以其不同的魅力走过了一段漫长的历史旅程。它不仅仅是一种简单的饮品,更是一种文化的象征,一种生活的态度。今天,我们将一起追溯啤酒从单一的饮品到丰富文化的演变过程,并感受Fendi Club精酿啤…...

Java 中 Map 常用类和数据结构详解
1. 引言 在Java编程中,Map是一种重要的数据结构,广泛应用于各种场景,Map实现了键值对(key-value)的存储方式,使得开发者能够快速检索、更新和操作数据。本篇文章将详细讲解Java中常用的Map类及其底层数据结…...
实时监控,动态调整 —— 淘宝商品详情API助力商家实现灵活经营
在讨论实时监控和动态调整的策略时,虽然我不能直接提供淘宝商品详情API的具体代码(因为这通常涉及商业机密和API密钥等敏感信息),但我可以给出一个概念性的示例,说明如何使用这类API来辅助商家实现灵活经营。 概念性示…...
WebGL常用接口和事件
目录 初始化WebGL上下文清除缓冲区缓冲区对象着色器和程序属性指针渲染事件监听错误处理纹理映射...

Golang | Leetcode Golang题解之第429题N叉树的层序遍历
题目: 题解: func levelOrder(root *Node) (ans [][]int) {if root nil {return}q : []*Node{root}for q ! nil {level : []int{}tmp : qq nilfor _, node : range tmp {level append(level, node.Val)q append(q, node.Children...)}ans append(a…...
数据库的全透明加密和半透明加密主要是针对数据存储安全的不同处理方式
数据库的全透明加密和半透明加密主要是针对数据存储安全的不同处理方式。 全透明加密(也称作无损加密或自动加密)就像是给文字戴上了一层无形的面具。在用户看来,他们在数据库中输入的是明文(比如姓名、密码)…...

MySQL的登录、访问、退出
一、登录: 访问MySQL服务器对应的命令:mysql.exe ,位置:C:\Program Files\MySQL\MySQL Server 8.0\bin (mysql.exe需要带参数执行,所以直接在图形界面下执行该命令会自动结束) 执行mysql.exe命令的时候出…...

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-09-25
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-09-25 1. PromSec: Prompt Optimization for Secure Generation of Functional Source Code with Large Language Models (LLMs) M Nazzal, I Khalil, A Khreishah, NH Phan - arXiv preprint arXiv:2409.12699, 2…...

阿里云ACP云计算备考笔记 (5)——弹性伸缩
目录 第一章 概述 第二章 弹性伸缩简介 1、弹性伸缩 2、垂直伸缩 3、优势 4、应用场景 ① 无规律的业务量波动 ② 有规律的业务量波动 ③ 无明显业务量波动 ④ 混合型业务 ⑤ 消息通知 ⑥ 生命周期挂钩 ⑦ 自定义方式 ⑧ 滚的升级 5、使用限制 第三章 主要定义 …...
基于数字孪生的水厂可视化平台建设:架构与实践
分享大纲: 1、数字孪生水厂可视化平台建设背景 2、数字孪生水厂可视化平台建设架构 3、数字孪生水厂可视化平台建设成效 近几年,数字孪生水厂的建设开展的如火如荼。作为提升水厂管理效率、优化资源的调度手段,基于数字孪生的水厂可视化平台的…...

Keil 中设置 STM32 Flash 和 RAM 地址详解
文章目录 Keil 中设置 STM32 Flash 和 RAM 地址详解一、Flash 和 RAM 配置界面(Target 选项卡)1. IROM1(用于配置 Flash)2. IRAM1(用于配置 RAM)二、链接器设置界面(Linker 选项卡)1. 勾选“Use Memory Layout from Target Dialog”2. 查看链接器参数(如果没有勾选上面…...

Python爬虫(一):爬虫伪装
一、网站防爬机制概述 在当今互联网环境中,具有一定规模或盈利性质的网站几乎都实施了各种防爬措施。这些措施主要分为两大类: 身份验证机制:直接将未经授权的爬虫阻挡在外反爬技术体系:通过各种技术手段增加爬虫获取数据的难度…...

回溯算法学习
一、电话号码的字母组合 import java.util.ArrayList; import java.util.List;import javax.management.loading.PrivateClassLoader;public class letterCombinations {private static final String[] KEYPAD {"", //0"", //1"abc", //2"…...
iOS性能调优实战:借助克魔(KeyMob)与常用工具深度洞察App瓶颈
在日常iOS开发过程中,性能问题往往是最令人头疼的一类Bug。尤其是在App上线前的压测阶段或是处理用户反馈的高发期,开发者往往需要面对卡顿、崩溃、能耗异常、日志混乱等一系列问题。这些问题表面上看似偶发,但背后往往隐藏着系统资源调度不当…...
Caliper 配置文件解析:fisco-bcos.json
config.yaml 文件 config.yaml 是 Caliper 的主配置文件,通常包含以下内容: test:name: fisco-bcos-test # 测试名称description: Performance test of FISCO-BCOS # 测试描述workers:type: local # 工作进程类型number: 5 # 工作进程数量monitor:type: - docker- pro…...
为什么要创建 Vue 实例
核心原因:Vue 需要一个「控制中心」来驱动整个应用 你可以把 Vue 实例想象成你应用的**「大脑」或「引擎」。它负责协调模板、数据、逻辑和行为,将它们变成一个活的、可交互的应用**。没有这个实例,你的代码只是一堆静态的 HTML、JavaScript 变量和函数,无法「活」起来。 …...

【堆垛策略】设计方法
堆垛策略的设计是积木堆叠系统的核心,直接影响堆叠的稳定性、效率和容错能力。以下是分层次的堆垛策略设计方法,涵盖基础规则、优化算法和容错机制: 1. 基础堆垛规则 (1) 物理稳定性优先 重心原则: 大尺寸/重量积木在下…...

向量几何的二元性:叉乘模长与内积投影的深层联系
在数学与物理的空间世界中,向量运算构成了理解几何结构的基石。叉乘(外积)与点积(内积)作为向量代数的两大支柱,表面上呈现出截然不同的几何意义与代数形式,却在深层次上揭示了向量间相互作用的…...