Golang每日一练(leetDay0034) 二叉树专题（3）

目录

100. 相同的树 Same Tree  🌟

101. 对称二叉树 Symmetric Tree  🌟

102. 二叉树的层序遍历 Binary Tree Level-order Traversal  🌟🌟

🌟 每日一练刷题专栏 🌟

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

二叉树专题（3）

100. 相同的树 Same Tree

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：

  • 两棵树上的节点数目都在范围 [0, 100] 内
  • -10^4 <= Node.val <= 10^4

代码1： 递归

package main

import (
	"fmt"
	"strconv"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func isSameTree(p *TreeNode, q *TreeNode) bool {
	if p == nil && q == nil {
		return true
	} else if p != nil && q != nil {
		if p.Val != q.Val {
			return false
		}
		return isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right)
	} else {
		return false
	}
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func levelOrder(root *TreeNode) string {
	if root == nil {
		return "[]"
	}
	arr := []int{}
	que := []*TreeNode{root}
	for len(que) > 0 {
		levelSize := len(que)
		for i := 0; i < levelSize; i++ {
			node := que[0]
			que = que[1:]
			if node == nil {
				arr = append(arr, null)
				continue
			}
			arr = append(arr, node.Val)
			que = append(que, node.Left, node.Right)
		}
	}
	size := len(arr)
	for size > 0 && arr[size-1] == null {
		arr = arr[:size-1]
		size = len(arr)
	}
	result := "["
	for i, n := range arr {
		if n == null {
			result += "null"
		} else {
			result += strconv.FormatInt(int64(n), 10)
		}
		if i < size-1 {
			result += ","
		} else {
			result += "]"
		}
	}
	return result
}

func main() {
	nums1 := []int{1, 2, 3}
	nums2 := []int{1, 2, 3}
	root1 := buildTree(nums1)
	root2 := buildTree(nums2)
	fmt.Println(levelOrder(root1))
	fmt.Println(levelOrder(root2))
	fmt.Println(isSameTree(root1, root2))

	nums1 = []int{1, 2}
	nums2 = []int{1, null, 2}
	root1 = buildTree(nums1)
	root2 = buildTree(nums2)
	fmt.Println(levelOrder(root1))
	fmt.Println(levelOrder(root2))
	fmt.Println(isSameTree(root1, root2))
}

输出：

[1,2,3]
[1,2,3]
true

[1,2]
[1,null,2]
false

代码2： 非递归

1. 定义一个栈，将 p 和 q 按顺序入栈。

2. 当栈不为空时，弹出栈顶元素，判断它们的值是否相等。如果不相等，返回 false。

3. 如果它们的值相等，继续判断它们的左右子树是否相等。如果 p 和 q 的左子树都不为空，则将它们的左子树按顺序入栈。如果 p 和 q 的右子树都不为空，则将它们的右子树按顺序入栈。

4. 如果栈为空，则说明 p 和 q 的所有节点都已经比较完毕，返回 true。

package main

import (
	"fmt"
	"strconv"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func isSameTree(p *TreeNode, q *TreeNode) bool {
	stack := []*TreeNode{p, q}
	for len(stack) > 0 {
		p, q := stack[len(stack)-2], stack[len(stack)-1]
		stack = stack[:len(stack)-2]
		if p == nil && q == nil {
			continue
		} else if p == nil || q == nil {
			return false
		} else if p.Val != q.Val {
			return false
		} else {
			stack = append(stack, p.Left, q.Left, p.Right, q.Right)
		}
	}
	return true
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func levelOrder(root *TreeNode) string {
	if root == nil {
		return "[]"
	}
	arr := []int{}
	que := []*TreeNode{root}
	for len(que) > 0 {
		levelSize := len(que)
		for i := 0; i < levelSize; i++ {
			node := que[0]
			que = que[1:]
			if node == nil {
				arr = append(arr, null)
				continue
			}
			arr = append(arr, node.Val)
			que = append(que, node.Left, node.Right)
		}
	}
	size := len(arr)
	for size > 0 && arr[size-1] == null {
		arr = arr[:size-1]
		size = len(arr)
	}
	result := "["
	for i, n := range arr {
		if n == null {
			result += "null"
		} else {
			result += strconv.FormatInt(int64(n), 10)
		}
		if i < size-1 {
			result += ","
		} else {
			result += "]"
		}
	}
	return result
}

func main() {
	nums1 := []int{1, 2, 3}
	nums2 := []int{1, 2, 3}
	root1 := buildTree(nums1)
	root2 := buildTree(nums2)
	fmt.Println(levelOrder(root1))
	fmt.Println(levelOrder(root2))
	fmt.Println(isSameTree(root1, root2))

	nums1 = []int{1, 2}
	nums2 = []int{1, null, 2}
	root1 = buildTree(nums1)
	root2 = buildTree(nums2)
	fmt.Println(levelOrder(root1))
	fmt.Println(levelOrder(root2))
	fmt.Println(isSameTree(root1, root2))
}

101. 对称二叉树 Symmetric Tree

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

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

提示：

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

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

代码1：递归

package main

import (
	"fmt"
	"strconv"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}
	return helper(root.Left, root.Right)
}

func helper(left, right *TreeNode) bool {
	if left == nil && right == nil {
		return true
	} else if left == nil || right == nil {
		return false
	} else if left.Val != right.Val {
		return false
	} else {
		return helper(left.Left, right.Right) && helper(left.Right, right.Left)
	}
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func levelOrder(root *TreeNode) string {
	if root == nil {
		return "[]"
	}
	arr := []int{}
	que := []*TreeNode{root}
	for len(que) > 0 {
		levelSize := len(que)
		for i := 0; i < levelSize; i++ {
			node := que[0]
			que = que[1:]
			if node == nil {
				arr = append(arr, null)
				continue
			}
			arr = append(arr, node.Val)
			que = append(que, node.Left, node.Right)
		}
	}
	size := len(arr)
	for size > 0 && arr[size-1] == null {
		arr = arr[:size-1]
		size = len(arr)
	}
	result := "["
	for i, n := range arr {
		if n == null {
			result += "null"
		} else {
			result += strconv.FormatInt(int64(n), 10)
		}
		if i < size-1 {
			result += ","
		} else {
			result += "]"
		}
	}
	return result
}

func main() {
	nums := []int{1, 2, 2, 3, 4, 4, 3}
	root := buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))

	nums = []int{1, 2, 2, null, 3, null, 3}
	root = buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))

	nums = []int{1, 2, 2, null, 3, 3}
	root = buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))
}

输出：

[1,2,2,3,4,4,3]
true

[1,2,2,null,3,null,3]
false

[1,2,2,null,3,3]
true

代码2： 非递归

使用队列进行迭代，每次将左右子树的节点按照对称的方式入队，然后依次出队进行比较，如果不相等则返回 false，如果相等则继续迭代。

package main

import (
	"fmt"
	"strconv"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}
	queue := []*TreeNode{root.Left, root.Right}
	for len(queue) > 0 {
		left, right := queue[0], queue[1]
		queue = queue[2:]
		if left == nil && right == nil {
			continue
		} else if left == nil || right == nil {
			return false
		} else if left.Val != right.Val {
			return false
		} else {
			queue = append(queue, left.Left, right.Right, left.Right, right.Left)
		}
	}
	return true
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func levelOrder(root *TreeNode) string {
	if root == nil {
		return "[]"
	}
	arr := []int{}
	que := []*TreeNode{root}
	for len(que) > 0 {
		levelSize := len(que)
		for i := 0; i < levelSize; i++ {
			node := que[0]
			que = que[1:]
			if node == nil {
				arr = append(arr, null)
				continue
			}
			arr = append(arr, node.Val)
			que = append(que, node.Left, node.Right)
		}
	}
	size := len(arr)
	for size > 0 && arr[size-1] == null {
		arr = arr[:size-1]
		size = len(arr)
	}
	result := "["
	for i, n := range arr {
		if n == null {
			result += "null"
		} else {
			result += strconv.FormatInt(int64(n), 10)
		}
		if i < size-1 {
			result += ","
		} else {
			result += "]"
		}
	}
	return result
}

func main() {
	nums := []int{1, 2, 2, 3, 4, 4, 3}
	root := buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))

	nums = []int{1, 2, 2, null, 3, null, 3}
	root = buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))

	nums = []int{1, 2, 2, null, 3, 3}
	root = buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))
}

代码3： 中序对称

先中序遍历二叉树，然后判断中序遍历结果是否是对称序列。

package main

import (
	"fmt"
	"strconv"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}
	vals := make([]int, 0)
	inorder(root, &vals)
	n := len(vals)
	for i := 0; i < n/2; i++ {
		if vals[i] != vals[n-i-1] {
			return false
		}
	}
	return true
}

func inorder(root *TreeNode, vals *[]int) {
	if root == nil {
		*vals = append(*vals, -1)
		return
	}
	inorder(root.Left, vals)
	*vals = append(*vals, root.Val)
	inorder(root.Right, vals)
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func levelOrder(root *TreeNode) string {
	if root == nil {
		return "[]"
	}
	arr := []int{}
	que := []*TreeNode{root}
	for len(que) > 0 {
		levelSize := len(que)
		for i := 0; i < levelSize; i++ {
			node := que[0]
			que = que[1:]
			if node == nil {
				arr = append(arr, null)
				continue
			}
			arr = append(arr, node.Val)
			que = append(que, node.Left, node.Right)
		}
	}
	size := len(arr)
	for size > 0 && arr[size-1] == null {
		arr = arr[:size-1]
		size = len(arr)
	}
	result := "["
	for i, n := range arr {
		if n == null {
			result += "null"
		} else {
			result += strconv.FormatInt(int64(n), 10)
		}
		if i < size-1 {
			result += ","
		} else {
			result += "]"
		}
	}
	return result
}

func main() {
	nums := []int{1, 2, 2, 3, 4, 4, 3}
	root := buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))

	nums = []int{1, 2, 2, null, 3, null, 3}
	root = buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))

	nums = []int{1, 2, 2, null, 3, 3}
	root = buildTree(nums)
	fmt.Println(levelOrder(root))
	fmt.Println(isSymmetric(root))
}

102. 二叉树的层序遍历 Binary Tree Level-order Traversal

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

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

示例 3：

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

提示：

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

代码1： 队列实现广度优先搜索 BFS

从根节点开始，将其加入队列中，然后不断从队列中取出节点，将其左右子节点加入队列中，直到队列为空，遍历完成。在遍历每一层时，将该层的节点值加入结果数组的末尾。

package main

import (
	"fmt"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func levelOrder(root *TreeNode) [][]int {
	if root == nil {
		return [][]int{}
	}
	var res [][]int
	queue := []*TreeNode{root}
	for len(queue) > 0 {
		size := len(queue)
		level := []int{}
		for i := 0; i < size; i++ {
			node := queue[0]
			queue = queue[1:]
			level = append(level, node.Val)
			if node.Left != nil {
				queue = append(queue, node.Left)
			}
			if node.Right != nil {
				queue = append(queue, node.Right)
			}
		}
		res = append(res, level)
	}
	return res
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func main() {
	nums := []int{3, 9, 20, null, null, 15, 7}
	root := buildTree(nums)
	fmt.Println(levelOrder(root))
}

输出：

[[3] [9 20] [15 7]]

代码2： 递归实现深度优先搜索 DFS

对于每一层，先遍历左子树，然后遍历右子树，直到遍历完所有层。在遍历每一层时，将该层的节点值加入结果数组的末尾。

package main

import (
	"fmt"
)

const null = -1 << 31

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func levelOrder(root *TreeNode) [][]int {
	var res [][]int
	dfs(root, 0, &res)
	return res
}

func dfs(node *TreeNode, level int, res *[][]int) {
	if node == nil {
		return
	}
	if level == len(*res) {
		*res = append(*res, []int{})
	}
	(*res)[level] = append((*res)[level], node.Val)
	dfs(node.Left, level+1, res)
	dfs(node.Right, level+1, res)
}

func buildTree(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	root := &TreeNode{Val: nums[0]}
	Queue := []*TreeNode{root}
	idx := 1
	for idx < len(nums) {
		node := Queue[0]
		Queue = Queue[1:]
		if nums[idx] != null {
			node.Left = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Left)
		}
		idx++
		if idx < len(nums) && nums[idx] != null {
			node.Right = &TreeNode{Val: nums[idx]}
			Queue = append(Queue, node.Right)
		}
		idx++
	}
	return root
}

func main() {
	nums := []int{3, 9, 20, null, null, 15, 7}
	root := buildTree(nums)
	fmt.Println(levelOrder(root))
}

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！ 

🌟 收藏，你的青睐是我努力的方向！ 

✎ 评论，你的意见是我进步的财富！  

☸ 主页：https://hannyang.blog.csdn.net/ 

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

程序设计方法学

程序设计方法学

体育竞技分析 问题分析 体育竞技分析 需求&#xff1a;毫厘是多少&#xff1f; 如何科学分析体育竞技比赛&#xff1f; 输入&#xff1a;球员的水平 输出&#xff1a;可预测的比赛成绩 体育竞技分析&#xff1a;模拟N场比赛 计算思维&#xff1a;抽象 自动化 模拟&am…
阅读更多...
【算法题】2583. 二叉树中的第 K 大层和

【算法题】2583. 二叉树中的第 K 大层和

题目&#xff1a; 给你一棵二叉树的根节点 root 和一个正整数 k 。 树中的 层和 是指 同一层 上节点值的总和。 返回树中第 k 大的层和&#xff08;不一定不同&#xff09;。如果树少于 k 层&#xff0c;则返回 -1 。 注意&#xff0c;如果两个节点与根节点的距离相同&…
阅读更多...
能够翻译文档的免费软件-免费翻译整个文档的软件

能够翻译文档的免费软件-免费翻译整个文档的软件

chatgpt怎么实现批量翻译 ChatGPT是一种基于人工智能技术的自然语言处理软件&#xff0c;可以实现快速、准确的批量翻译操作&#xff0c;同时也支持多种语言翻译。下面是 ChatGPT 的批量翻译操作流程&#xff1a; 步骤 1: 确定翻译语言和翻译文本 首先需要确定要翻译的原文本…
阅读更多...
java学习之局部内部类

java学习之局部内部类

目录 一、内部类简介 二、内部类的分类 三、局部内部类 第一点 第二点 第三点 第四点 第五点 第六点 第七点 一、内部类简介 类的五大成员&#xff1a;属性、方法、构造器、代码块、内部类 package com.hspedu.innerclass;public class InnerClass01 {public static…
阅读更多...
AOP与SpringBoot使用AOP实例

AOP与SpringBoot使用AOP实例

AOP&#xff1a;Aspect Oriented Programming&#xff08;面向切面编程、面向方面编程&#xff09;&#xff0c;其实就是面向特定方法编程。 动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术&#xff0c;旨在管理bean对象的过程中&#xff0c;主要通过…
阅读更多...
Windows使用Dockers+battery historian踩坑记

Windows使用Dockers+battery historian踩坑记

1、首先&#xff0c;需要翻墙。 2、然后安装Dockers&#xff0c;网上好多博客说安装Docker Toolbox&#xff0c;我亲测无效&#xff0c;卸载后安装Docker for Windows&#xff0c;安装完成后打开&#xff0c;会提示&#xff1a; Hardware assisted virtualization and data e…
阅读更多...
Mybatis03学习笔记

Mybatis03学习笔记

目录 使用注解开发 设置事务自动提交 mybatis运行原理 注解CRUD lombok使用&#xff08;偷懒神器&#xff0c;大神都不建议使用&#xff09; 复杂查询环境&#xff08;多对一&#xff09; 复杂查询环境&#xff08;一对多&#xff09; 动态sql环境搭建 动态sql常用标签…
阅读更多...
大数据实战 --- 淘宝用户行为

大数据实战 --- 淘宝用户行为

目录 开发环境 数据描述 功能需求 数据准备 数据清洗 用户行为分析 找出有价值的用户 开发环境 HadoopHiveSparkHBase 启动Hadoop&#xff1a;start-all.sh 启动zookeeper&#xff1a;zkServer.sh start 启动Hive&#xff1a; nohup hiveserver2 1>/dev/null 2>…
阅读更多...
生成树端口选举

生成树端口选举

所有交换机运行RSTP，SW1优先级4096，SW2优先级4096，SW3优先级8192，SW1的G0/0/1、G0/0/2接口通过手动模式加入Eth-Trunk 1，SW1的G0/0/3、G0/0/4接口通过手动模式加入Eth-Trunk 2，SW2的G0/0/1、G0/0/2接口通过手动模式加入Eth-Trunk 1，SW3的G0/0/1、G0/0/2接口通过手动模式…
阅读更多...
【Python】Python读写.xlsx文件（基本操作、空值补全等）

【Python】Python读写.xlsx文件（基本操作、空值补全等）

【Python】Python读写.xlsx文件&#xff08;Pandas&#xff09; 文章目录 【Python】Python读写.xlsx文件&#xff08;Pandas&#xff09;1. 介绍2. Pandas读写xlsx文件2.1 基本操作2.1.1 实现任务2.1.2 代码2.1.3 结果 2.2 进阶操作2.2.1 写操作2.2.2 查看数据表的基本信息2.2…
阅读更多...
电脑有自带的录屏功能吗？电脑录屏如何录人脸

电脑有自带的录屏功能吗？电脑录屏如何录人脸

案例&#xff1a;所有电脑都有自带的录屏功能吗&#xff1f; “在网上了解到电脑有录屏功能&#xff0c;但是我在我的电脑上又找不到。想问问小伙伴们是所有的电脑都有自带的录屏功能吗&#xff1f;怎样才能找到电脑自带的录屏功能&#xff1f;” 在日常使用电脑时&#xff0…
阅读更多...
Python 无监督学习实用指南：1~5

Python 无监督学习实用指南：1~5

原文&#xff1a;Hands-on unsupervised learning with Python 协议&#xff1a;CC BY-NC-SA 4.0 译者&#xff1a;飞龙 本文来自【ApacheCN 深度学习 译文集】&#xff0c;采用译后编辑&#xff08;MTPE&#xff09;流程来尽可能提升效率。 不要担心自己的形象&#xff0c;只关…
阅读更多...
封装通用el-form表单（2种方式）

封装通用el-form表单（2种方式）

1、序言 项目地址&#xff1a;git clone form-demo: 封装通用el-form 一个后台管理系统最常见的是表单&#xff0c;表单最常见的是输入框、下拉选择、日期选择、单选、复选框等等&#xff0c; 系统添加若干模块&#xff0c;就复制粘贴若干个el-form、el-form-item&#xff0c;有…
阅读更多...
重学Java设计模式-行为型模式-责任链模式

重学Java设计模式-行为型模式-责任链模式

重学Java设计模式-行为型模式-责任链模式 内容摘自&#xff1a;https://bugstack.cn/md/develop/design-pattern/2020-06-18-重学 Java 设计模式《实战责任链模式》.html#重学-java-设计模式-实战责任链模式「模拟618电商大促期间-项目上线流程多级负责人审批场景」 责任链模…
阅读更多...
Shell 脚本编程

Shell 脚本编程

1. shell 概述 &#x1f95e; shell 是一个命令行解释器&#xff0c;它能接受应用程序、用户 的命令&#xff0c;然后调用操作系统内核。 ⭐ 还是一门 功能强大的编程语言&#xff0c;易编写、易调试、灵活性强。 2. shell入门 &#xff08;1&#xff09;脚本格式 &#x1f…
阅读更多...
js中 = 等号赋值的问题，Js中对象的引用问题，深浅拷贝

js中 = 等号赋值的问题，Js中对象的引用问题，深浅拷贝

js "" 赋值符号 在js中 “”对于基本数据类型是赋值符号&#xff0c;比较&#xff08; 或 &#xff09;的时候是值&#xff1b;对于引用数据类型-对象来说 是地址引用&#xff0c;比较的时候是比较的地址。 基本数据类型和引用数据类型的比较 let a 3; let b a;…
阅读更多...
离散数学_九章：关系（1）

离散数学_九章：关系（1）

关系 9.1关系及其性质 1、二元关系 2、集合A上的关系 3、n元素集合 有多少个关系&#xff1f; 4、关系的性质 1. 自反 2. 对称 3. 反对称 4. 传递 5、关系的组合 关系的合成 关系的幂 9.1关系及其性质 1、二元关系 设A和B是集合&#xff0c;一个从 A 到 B 的二元关…
阅读更多...
stm32当中GPIO输出知识点汇总（GPIO的八种模式及其原理）

stm32当中GPIO输出知识点汇总（GPIO的八种模式及其原理）

一、GPIO工作模式. 1. 四种输入模式 GPIO_Mode_IN_FLOATING 浮空输入模式 GPIO_Mode_IPU 上拉输入模式 GPIO_Mode_IPD 下拉输入模式 GPIO_Mode_AIN 模拟输入模式 2. 四种输出模式 GPIO_Mode_Out_OD 开漏输出模式 GPIO_Mode_Out_PP 推挽输出模式 GPIO_Mod…
阅读更多...
CentOS7-部署Tomcat并运行Jpress

CentOS7-部署Tomcat并运行Jpress

1. 简述静态网页和动态网页的区别。 2. 简述 Webl.0 和 Web2.0 的区别。 3. 安装tomcat8&#xff0c;配置服务启动脚本&#xff0c;部署jpress应用。1、简述静态网页和动态网页的区别 静态网页&#xff1a; 请求响应信息&#xff0c;发给客户端进行处理&#xff0c;由浏览器进…
阅读更多...
目标检测基础之IOU计算

目标检测基础之IOU计算

目标检测基础之IOU计算 概念理解——什么是IOUdemo后记 概念理解——什么是IOU IOU 交并比&#xff08;Intersection over Union&#xff09;&#xff0c;从字面上很容易理解&#xff1a;计算交集在并集的比重。从网上截张图看看 I O U A ∩ B A ∪ B IOU \frac{A \cap B}…
阅读更多...
最新文章

Copyright @ 2022~2023