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

news2024/11/28 20:50:23

目录

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每日一练 专栏

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

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

相关文章

pdf怎么转换ppt格式，两个方法转换

pdf怎么转换ppt格式，两个方法转换

PDF作为一种常用的文件格式&#xff0c;被大众所熟悉。虽然PDF具备的稳定性&#xff0c;安全性&#xff0c;以及很强的兼容性可以让我们更方便顺畅的阅读PDF文件&#xff0c;但若是有需要展示PDF文件内容的时候&#xff0c;其优点就没有那么凸显了&#xff0c;这时还是将pdf转换…
阅读更多...
数据结构与算法基础（王卓）（25）线性表的查找（1）：顺序查找（线性查找)

数据结构与算法基础（王卓）（25）线性表的查找（1）：顺序查找（线性查找)

基本基础概念&#xff1a; 看这就不用去翻PPT了 查找&#xff1a; 根据给定的某个值&#xff0c;在查找表中确定一个与其关键字等于给定值的数据元素&#xff08;或记录&#xff09; 关键字&#xff1a; 用来表示一个数据元素&#xff08;或记录&#xff09;的某个数据项的值 主…
阅读更多...
系统安全与应用【下】

系统安全与应用【下】

文章目录1.开关机安全控制1.1 GRUB限制1.2 实例&#xff1a;GRUB 菜单设置密码2.终端登录安全控制2.1 限制root只在安全终端登录2.2 禁止普通用户登录3.弱口令检测3.1 Joth the Ripper,JR4.网络端口扫描4.1 nmap命令1.开关机安全控制 1.1 GRUB限制 限制更改GRUB引导参数 通常情…
阅读更多...
读懂MAC地址

读懂MAC地址

MAC地址是一种用于标识计算机网络设备的唯一地址。它是由48个二进制数字组成的&#xff0c;通常表示为12个十六进制数字&#xff0c;每两个数字之间用冒号或连字符分隔开。MAC地址由设备制造商在生产过程中分配&#xff0c;以确保网络上每个设备都有唯一的标识符。 MAC地址的规…
阅读更多...
投影仪怎么连接电脑？快来看看这3种方法！

投影仪怎么连接电脑？快来看看这3种方法！

案例&#xff1a;如何连接电脑和投影仪&#xff1f; 【想看电影&#xff0c;但是电脑屏幕太小&#xff0c;我想把电脑上的内容通过投影仪投到大屏幕上。有小伙伴知道如何连接电脑和投影仪吗&#xff1f;谢谢大家&#xff01;】 使用投影仪可以将电脑或其他设备上的内容投放到…
阅读更多...
Java——矩形覆盖

Java——矩形覆盖

题目链接 牛客在线oj题——矩形覆盖 题目描述 我们可以用 21 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 21 的小矩形无重叠地覆盖一个 2*n 的大矩形&#xff0c;从同一个方向看总共有多少种不同的方法&#xff1f; 数据范围&#xff1a;0≤n≤38 进阶&#xff1…
阅读更多...
九龙证券|啤酒龙头一季度净利暴增逾70倍！钛白粉开启年内第三次涨价

九龙证券|啤酒龙头一季度净利暴增逾70倍！钛白粉开启年内第三次涨价

业内人士遍及认为&#xff0c;随着下流需求逐渐改进&#xff0c;钛白粉职业景气量有望恢复。 燕京啤酒昨日晚间发布一季度成绩预告&#xff0c;公司2023年一季度预计完成归母净利润6200万至6600万元&#xff0c;同比增加7076.76%至7539.77%。对于成绩变动的原因&#xff0c;燕京…
阅读更多...
K8s为什么要放弃Docker

K8s为什么要放弃Docker

公司定期分享整理的资料 放弃始由 https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.20.md#deprecation 2020 年&#xff0c;k8s 1.20 终于正式向 Docker “宣战”&#xff1a;kubelet将弃用 Docker 支持&#xff0c;并将在未来的版本中完全移除。…
阅读更多...
Linux高性能服务器编程｜阅读笔记：第1章 - TCP/IP协议族

Linux高性能服务器编程｜阅读笔记：第1章 - TCP/IP协议族

简介 Hello！ 非常感谢您阅读海轰的文章，倘若文中有错误的地方，欢迎您指出～ ଘ(੭ˊᵕˋ)੭ 昵称：海轰 标签：程序猿｜C++选手｜学生 简介：因C语言结识编程，随后转入计算机专业，获得过国家奖学金，有幸在竞赛中拿过一些国奖、省奖…已保研 学习经验：扎实基础 + 多做笔…
阅读更多...
CLIMS:弱监督语义分割的跨语言图像匹配

CLIMS:弱监督语义分割的跨语言图像匹配

文章目录CLIMS: Cross Language Image Matching for Weakly Supervised Semantic Segmentation摘要方法语言图像匹配框架实验结果CLIMS: Cross Language Image Matching for Weakly Supervised Semantic Segmentation 摘要 存在的问题 CAM(类激活图)通常只激活有区别的对象区…
阅读更多...
第二章 数据类型与变量

第二章 数据类型与变量

文章目录1. 字面常量2. 数据类型3. 变量3.1 变量概念3.2 语法格式3.3 整形变量3.3.1 int整型变量(4 个字节)3.3.2 long长整型变量&#xff08;8 个字节&#xff09;3.3.3 short短整型变量(2 个字节)3.3.4 byte字节型变量&#xff08;1个字节&#xff09;3.4 浮点型变量3.4.1 do…
阅读更多...
图片的四个角怎么做成圆弧形，2种方法分享

图片的四个角怎么做成圆弧形，2种方法分享

图片的四个角怎么做成圆弧形&#xff1f;今天来说一说直角和圆弧&#xff0c;小伙伴们可能会疑惑了&#xff0c;怎么今天讲的内容和之前不一样啊&#xff0c;不要着急干货在后面&#xff0c;听我娓娓道来。相信很多小伙伴们都使用过iphone手机&#xff0c;每年的产品发布会都会…
阅读更多...
用高中生的思维写一篇MATLAB入门

用高中生的思维写一篇MATLAB入门

文章目录一、简介二、MATLAB的工作界面三、基本语句1、if语句2、switch语句3、try语句4、for语句和while语句5、break语句和continus语句四、数值运算1、基本算术运算2、format命令3、关系运算4、逻辑运算5、特殊变量和常数6、数学函数五、二维平面绘图1、关于颜色和数据标记点…
阅读更多...
微积分——用积分定义自然对数的动机

微积分——用积分定义自然对数的动机

第6章 对数函数&#xff0c;指数函数和反三角函数 目录 第6章 对数函数&#xff0c;指数函数和反三角函数 6.1 引言 6.2 用积分定义自然对数的动机 内容来源&#xff1a;<> Tom M. Apostol 6.1 引言 每当有人将他的注意力集中到数量关系的时候&#xff0c;他要么是…
阅读更多...
NIFI大数据进阶_实时同步MySql的数据到Hive中去_可增量同步_实时监控MySql数据库变化_操作方法说明_02---大数据之Nifi工作笔记0034

NIFI大数据进阶_实时同步MySql的数据到Hive中去_可增量同步_实时监控MySql数据库变化_操作方法说明_02---大数据之Nifi工作笔记0034

然后我们继续来看,如果需要同步,当然需要先开启mysqlbin log日志了 可以看到开启操作 在windows和linux上开启binlog日志 然后看一下 在windows上开启mysql的binlog的方法
阅读更多...
ES X-Pack密码认证与用户管理

ES X-Pack密码认证与用户管理

用户数据的安全性一直被人诟病且默认没有密码认证&#xff0c;Elasticsearch在6.8之前官方的X-pack安全认证功能都是收费的&#xff0c;所以很多人都采用Search Guard或者ReadOnly REST这些免费的安全插件对Elasticsearch进行安全认证。从Elasticsearch 6.8开始&#xff0c;Sec…
阅读更多...
Java集成工作流经典案例（多个项目优化精华版）

Java集成工作流经典案例（多个项目优化精华版）

前言 activiti工作流引擎项目&#xff0c;企业erp、oa、hr、crm等企事业办公系统轻松落地&#xff0c;请假审批demo从流程绘制到审批结束实例。 一、项目形式 springbootvueactiviti集成了activiti在线编辑器&#xff0c;流行的前后端分离部署开发模式&#xff0c;快速开发平…
阅读更多...
爆款来袭！刷屏的Auto-GPT与ChatGPT区别，GPT成为AI领域最受关注的技术，你还在等什么？(狂飙 啊。。。Github 80k star了)

爆款来袭！刷屏的Auto-GPT与ChatGPT区别，GPT成为AI领域最受关注的技术，你还在等什么？(狂飙 啊。。。Github 80k star了)

最近全网火爆刷屏的热门词auto-gpt&#xff0c;在全网站频频出现: "ChatGPT 过时了&#xff0c;Auto-GPT才是未来" "它所具备的能力主打的就是一个“自主”&#xff0c;完全不用人类插手的那种&#xff01;" 到底什么是auto-gpt? 1、Auto-GPT和ChatGP…
阅读更多...
zabbix创建自定义监控模板之自动注册，代理服务器

zabbix创建自定义监控模板之自动注册，代理服务器

目录 第一章zabbix 自动注册&#xff08;对于 agent2 是主动模式&#xff09; 1.1.环境准备 1.2.修改 zabbix-agent2 配置文件 1.3.在 Web 页面配置自动注册 第二章部署 zabbix 代理服务器 2.1.环境部署 2.2.安装 zabbix 所需的数据库yum install -y mariadb-server mar…
阅读更多...
ChatGPT应用场景与工具推荐

ChatGPT应用场景与工具推荐

目录 写在前面 一、关于ChatGPT 二、应用实例 1.写文章 2.入门新的知识 3.解决疑难问题 4.生成预演问题 5.文本改写 6.语言翻译 7.思维导图 8.PDF阅读理解 9.操作格式化的数据 10.模拟场景 11.写代码 三、现存局限 写在前面 本文会简单介绍ChatGPT的特点、局限以…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023