文心一言 VS 讯飞星火 VS chatgpt （177）-- 算法导论13.3 6题

六、用go语言，说明如果红黑树的表示中不提供父指针，应当如何有效地实现 RB-INSERT。

文心一言：

红黑树是一种自平衡的二叉搜索树，其中每个节点都包含一个颜色属性（红色或黑色），并且满足以下性质：

节点是红色或黑色。
根节点是黑色。
所有叶子节点（NIL或空节点）都是黑色。
如果一个节点是红色的，则它的子节点都是黑色的。
从任一节点到其每个叶子节点的所有路径都包含相同数目的黑色节点。
在红黑树的表示中，通常会为每个节点提供一个父指针，这样在插入或删除节点时可以方便地找到父节点。但是，如果没有提供父指针，实现RB-INSERT操作将会稍微复杂一些。

在这种情况下，我们需要使用递归来实现RB-INSERT操作。以下是一个使用Go语言实现的示例：

type Node struct {  
    Key    int  
    Color  string  
    Parent *Node  
}  
  
type RedBlackTree struct {  
    Root *Node  
}  
  
func (t *RedBlackTree) Insert(key int) {  
    newNode := &Node{Key: key, Color: "Red"}  
    parent := t.Root  
    if parent == nil {  
        newNode.Color = "Black" // 根节点必须是黑色的  
        t.Root = newNode  
        return  
    }  
    current := parent  
    for current != nil {  
        parent = current  
        if newNode.Key < current.Key {  
            current = current.LeftChild()  
        } else {  
            current = current.RightChild()  
        }  
    }  
    newNode.Parent = parent  
    if newNode.Key < parent.Key {  
        parent.LeftChild(newNode)  
    } else {  
        parent.RightChild(newNode)  
    }  
    t.FixInsert(newNode) // 修复红黑树性质  
}  
  
func (n *Node) LeftChild() *Node {  
    if n == nil {  
        return nil  
    } else if n.Left != nil {  
        return n.Left  
    } else if n.Right != nil {  
        return n.Right  
    } else {  
        return nil // 叶子节点或NIL节点没有左孩子，返回nil  
    }  
}  
  
func (n *Node) RightChild() *Node {  
    if n == nil {  
        return nil  
    } else if n.Right != nil {  
        return n.Right  
    } else if n.Left != nil {  
        return n.Left  
    } else {  
        return nil // 叶子节点或NIL节点没有右孩子，返回nil  
    }  
}  
  
func (n *Node) LeftChild(newNode *Node) {  
    if n == nil { // NIL节点作为父节点的情况，需要特殊处理左孩子和右孩子的设置，这里省略处理细节...  
    } else if n.Left == nil { // 普通设置左孩子的情况，这里省略处理细节...  
    } else if n.Right == nil { // 普通设置右孩子的情况，这里省略处理细节...  
    } else { // 普通设置左右孩子的情况，这里省略处理细节...  
    }  
}  
func (n *Node) RightChild(newNode *Node) { // 与设置左孩子类似，这里省略处理细节...  
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火：

红黑树是一种自平衡的二叉查找树，它通过维护节点的颜色和旋转操作来确保树的高度始终保持在log(n)。在红黑树中，每个节点都有一个颜色属性（红色或黑色），并且每个节点都有两个子节点（左子节点和右子节点）。

红黑树的插入操作（RB-INSERT）的基本步骤如下：

  1. 将新节点插入到普通二叉搜索树中。
  2. 如果新节点是根节点，将其颜色设置为黑色。
  3. 否则，从新节点开始向上遍历树，对每个经过的节点执行以下操作：
    • 如果当前节点是红色，将其颜色更改为黑色，并将其父节点和祖父节点的颜色更改为红色。然后根据祖父节点的位置进行相应的旋转操作。
  4. 将根节点的颜色设置为黑色。

由于题目要求不提供父指针，我们可以使用一个额外的数据结构（如链表）来存储每个节点的父节点。这样，在执行插入操作时，我们可以通过遍历这个链表来找到每个节点的父节点。

以下是用Go语言实现RB-INSERT的代码：

package main

import "fmt"

type Node struct {
	key   int
	color string
	left  *Node
	right *Node
}

func insert(root *Node, key int) *Node {
	node := &Node{key: key, color: "red", left: nil, right: nil}

	if root == nil {
		return node
	}

	parent := findParent(root, key)
	if parent.key > key {
		parent.left = node
	} else {
		parent.right = node
	}

	fixInsert(node)
	return root
}

func findParent(root *Node, key int) *Node {
	if root == nil || root.key == key {
		return nil
	}

	if root.key > key {
		return findParent(root.left, key)
	}

	return findParent(root.right, key)
}

func fixInsert(node *Node) {
	for node != nil && node.color == "red" {
		if node.parent.color == "red" {
			node.parent.color = "black"
			node.grandparent.color = "red"
			node = node.grandparent
		} else if node == node.parent.left && node.parent.parent.color == "red" {
			node = node.parent.parent
			rotateRight(node)
		} else if node == node.parent.right && node.parent.parent.color == "red" {
			node = node.parent.parent
			rotateLeft(node)
		} else {
			break
		}
	}

	root.color = "black"
}

func rotateLeft(node *Node) {
	temp := node.right
	node.right = temp.left
	temp.left = node
}

func rotateRight(node *Node) {
	temp := node.left
	node.left = temp.right
	temp.right = node
}

func main() {
	root := nil
	root = insert(root, 10)
	root = insert(root, 20)
	root = insert(root, 30)
	root = insert(root, 40)
	root = insert(root, 50)
	root = insert(root, 25)

	fmt.Println("Root color:", root.color)
}

这段代码首先定义了一个Node结构体，用于表示红黑树中的节点。然后实现了insert函数，用于插入新节点。findParent函数用于查找给定键的父节点。fixInsert函数用于修复插入操作后可能导致的红黑树性质破坏的情况。最后，rotateLeft和rotateRight函数分别实现了左旋和右旋操作。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

360智脑：

在 Go 语言中，红黑树是一种自平衡二叉查找树，它提供了高效的数据查找和插入操作。在红黑树的实现中，通常会使用一个节点指针来指向父节点，以便在插入和删除操作中维护树的平衡性。但是，如果红黑树的表示中不提供父指针，我们仍然可以通过一些技巧来实现 RB-INSERT 操作。

以下是一个在不提供父指针的情况下实现 RB-INSERT 的方法：

  1. 首先，我们需要在每个节点中增加一个额外的“标记”字段，用于记录节点的父节点。这个标记可以是一个整数值，表示节点的深度，或者是一个指向最近祖先节点的指针。

  2. 在插入新节点时，我们首先执行常规的二叉查找树插入操作。然后，我们需要找到新节点的最近祖先节点，可以通过递归遍历树的深度来实现。在这个过程中，我们可以使用一个栈来存储节点的路径，以便在找到最近祖先节点后，可以通过栈弹出操作来找到祖先节点。

  3. 找到最近祖先节点后，我们需要执行红黑树的旋转操作来维护树的平衡性。这时，我们需要知道旋转的类型（左旋或右旋）以及旋转的节点。通常情况下，我们可以通过判断新节点和其父节点的颜色以及它们在树中的位置来确定旋转的类型。但是，在不提供父指针的情况下，我们可以通过以下方法来确定旋转类型：

  • 如果新节点和其最近祖先节点的颜色相同，我们需要执行左旋或右旋操作，具体取决于新节点是位于其祖先节点的左侧还是右侧。
  • 如果新节点和其最近祖先节点的颜色不同，我们需要执行右旋或左旋操作，具体取决于新节点是位于其祖先节点的左侧还是右侧。

  1. 执行旋转操作后，我们需要更新树中节点的颜色和深度，并继续向上遍历树，直到找到根节点或找到一个黑色节点。在这个过程中，我们需要将新节点的颜色设置为红色，并更新每个节点的深度。

  2. 最后，我们需要更新根节点的颜色和深度，并完成 RB-INSERT 操作。

总之，在不提供父指针的情况下，我们仍然可以通过增加额外的标记字段和使用栈来实现 RB-INSERT 操作。但是，这种方法比使用父指针的方法更加复杂和低效。因此，在实际应用中，我们通常会使用父指针来简化红黑树的实现。

在这里插入图片描述

智谱清言：

在Go语言中，如果红黑树的表示中不提供父指针，实现RB-INSERT算法需要依靠某些辅助结构来有效地查找和修改节点。以下是一种可能的实现方法：

  1. 引入一个栈（stack）来存储从根节点到待插入节点z的路径。在插入过程中，每当访问一个新节点，就将它压入栈中。
  2. 定义一个链式栈（linked stack），其节点类型为snode，包含一个node类型的数据域和一个指向下一个节点的指针。
  3. 使用stack结构体来表示栈，其中包含一个指向栈顶节点的指针。
  4. 实现StackInsert和StackPop函数来分别向栈中插入元素和从栈中弹出元素。
  5. 在进行RB-INSERT操作时，首先将根节点压入栈中。然后，从栈顶节点开始，执行以下操作：
    a. 如果当前节点为空，或者待插入节点z的键已经存在于当前节点，则结束插入操作。
    b. 如果当前节点的左子节点为空，将待插入节点z作为左子节点插入到当前节点。设置z的父节点为当前节点，并将z的颜色设置为红色。然后更新红黑树的性质，并进行必要的旋转操作。
    c. 如果当前节点的右子节点为空，将待插入节点z作为右子节点插入到当前节点。设置z的父节点为当前节点，并将z的颜色设置为红色。然后更新红黑树的性质，并进行必要的旋转操作。
    d. 如果当前节点的左右子节点都不为空，说明当前节点是待插入节点z的祖先节点。将当前节点从栈中弹出，并将栈顶节点（即当前节点的父节点）移动到栈顶。重复步骤5。
  6. 完成上述步骤后，如果栈中仍有元素，说明存在违反红黑树性质的情况。此时，需要通过旋转操作来修复红黑树的性质，直至栈为空。
    通过以上方法，即使红黑树的表示中不提供父指针，我们也可以有效地实现RB-INSERT算法。需要注意的是，这里只提供了一种可能的实现方法，具体的实现细节可能会因不同的应用场景和需求而有所差异。

在这里插入图片描述

通义千问：

在红黑树的表示中，如果选择不存储父节点指针（parent pointer），插入新节点（RB-INSERT）时需要采取一种间接的方式来跟踪和更新父节点。由于红黑树要求保持特定的性质（如节点是红色或黑色、任何路径上从根到叶子节点的黑节点数量相同等），在插入过程中可能需要进行旋转和重新着色操作，而这些通常涉及父节点。

为了在没有父指针的情况下实现 RB-INSERT，可以采用栈来记录从根节点到待插入节点路径上的所有中间节点。具体步骤如下：

  1. 初始化：

    • 创建一个栈 path 来存储节点。
    • 从根节点开始遍历红黑树。

  2. 查找插入位置：

    • 遍历树的过程中，将经过的节点依次压入栈中。
    • 当找到待插入位置（即小于等于新节点的所有节点都在其左侧，大于新节点的所有节点在其右侧的位置）时停止遍历。

  3. 插入新节点：

    • 将新节点插入到找到的位置，作为当前栈顶节点的孩子节点。
    • 新节点初始颜色设为红色。

  4. 修复红黑树性质：

    • 弹出栈顶元素作为新节点的父亲节点，并检查红黑树的性质是否被破坏。
    • 使用栈来追踪祖辈关系，并执行相应的旋转和重新着色操作以恢复红黑树的性质，例如：
      • 如果新插入节点是红色且其父节点也是红色，那么违反了红黑树的“红节点不能连续”规则，需要通过旋转和变色来调整。
      • 根据新节点与父节点以及祖父节点的关系，执行左旋、右旋或者左右旋（先左后右）。

  5. 完成插入：

    • 调整完树结构并确保所有红黑树性质满足后，结束插入过程。

以下是简化后的伪代码描述：

func RBInsert(tree *Rbtree, value int) {
    var node *Node = &tree.sentinel // 哨兵节点作为起始点
    var parent *Node = nil        // 初始化父节点为 nil
    var path []*Node              // 创建用于保存路径的栈

    for {
        parent = node
        if value < node.value { // 左子树方向
            node = node.left
            if node == tree.sentinel { // 找到插入位置
                break
            }
        } else { // 右子树方向
            node = node.right
            if node == tree.sentinel {
                break
            }
        }
        path = append(path, node) // 将节点压入栈
    }

    newNode := &Node{value: value, color: RED}
    if value < parent.value {
        parent.left = newNode
    } else {
        parent.right = newNode
    }

    newNode.parent = parent // 即使不存储在结构体中，这里仍需临时设置以便于接下来的操作

    // 修复红黑树性质
    FixRedBlackTreeProperties(tree, newNode, path)

    // ...
}

// FixRedBlackTreeProperties 是一个虚构函数，它会根据实际情况执行旋转和变色操作来修复红黑树性质
func FixRedBlackTreeProperties(tree *Rbtree, insertedNode *Node, path []*Node) {
    // 这里实现旋转和变色逻辑
}

请注意，实际的 Go 语言实现会更加复杂，包括实现修复红黑树性质的具体逻辑。在修复过程中，即使没有显式的父指针，也可以利用栈中的信息推断出需要调整的节点之间的关系。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

天工：

在 Go 语言中，如果红黑树表示中不提供 parent 指针，我们可以使用以下方法来实现 RB- INSERT：

  1. 定义一个节点类型，包含 key、value、color、parent 和 left、right 指针。
  2. 在插入节点时，首先判断新节点的颜色是否为黑，如果是黑则直接插入节点，否则需要对节点进行旋转操作。
  3. 插入节点后，需要对节点的颜色进行重新着色，保证树的平衡性。

下面是一个实现 RB-插入的示例代码：

type Node struct {
    Key   int
    Value int
    Color byte
    Parent *Node
    Left *Node
    Right *Node
}

func (n *Node) rotateLeft() {
    x := n.Right
    n.Right = x.Left
    if x.Left != nil {
        x.Left.Parent = n
    }
    x.Parent = n.Parent
    if n.Parent != nil && n == n.Parent.Left {
        n.Parent.Right = x
    } else {
        n.Parent.Left = x
    }
    x.Left = n
}

func (n *Node) rotateRight() {
    y := n.Left
    n.Left = y.Right
    if y.Right != nil {
        y.Right.Parent = n
    }
    y.Parent = n.Parent
    if n.Parent != nil && n == n.Parent.Right {
        n.Parent.Left = y
    } else {
        n.Parent.Right = y
    }
    y.Right = n
}

// 插入节点
func RBInsert(n *Node, key int) {
    if n == nil {
        return
    }
    if key < n.Key {
        n.Left = RBInsert(n.Left, key)
        if n.Left != nil {
            n.Left.Color = 'R'
        }
    } else if key > n.Key {
        n.Right = RBInsert(n.Right, key)
        if n.Right != nil {
            n.Right.Color = 'R'
        }
    } else {
        n.Key = key
        n.Color = 'R'
    }
}

在上述代码中，我们通过 rotateLeft() 和 rotateRight() 方法来实现节点的旋转操作，保证树的平衡性。在插入节点时，我们先判断节点的颜色是否为黑，如果是黑则直接插入节点，否则需要对节点进行旋转操作。插入节点后，我们需要对节点的颜色进行重新着色，保证树的平衡性。

在这里插入图片描述

在这里插入图片描述

灵小智：

如果在红黑树的表示中不提供父指针，我们可以通过其他方式有效地实现RB-INSERT算法。这里我将使用Go语言来演示具体实现。

首先，我们需要定义红黑树的节点结构体，包含键值、颜色、左子节点和右子节点等属性：

type Node struct {
    key    int
    color  string
    left   *Node
    right  *Node
}

接下来，我们实现RB-INSERT算法。由于没有父指针，我们需要借助递归来定位插入位置，并在递归过程中保持对祖先节点的颜色状态。

func RBInsert(root *Node, key int) *Node {
    if root == nil {
        return &Node{key: key, color: "RED"}
    }

    if key < root.key {
        root.left = RBInsert(root.left, key)
        if root.color == "RED" {
            return root
        }
        if root.left.color == "RED" && isRed(root.left.left) {
            return fixLeftLeftCase(root)
        }
        if root.left.color == "RED" && isRed(root.left.right) {
            return fixLeftRightCase(root)
        }
    } else if key > root.key {
        root.right = RBInsert(root.right, key)
        if root.color == "RED" {
            return root
        }
        if root.right.color == "RED" && isRed(root.right.right) {
            return fixRightRightCase(root)
        }
        if root.right.color == "RED" && isRed(root.right.left) {
            return fixRightLeftCase(root)
        }
    }

    return root
}

在RBInsert函数中，我们首先根据键值的大小选择递归向左子树或右子树插入。然后，根据祖先节点和当前节点的颜色关系执行相应的修复操作，这里假设存在fixLeftLeftCase、fixLeftRightCase、fixRightRightCase和fixRightLeftCase等修复函数来处理不同情况下的平衡恢复操作。

最后，我们可以使用RBInsert函数将新节点插入红黑树中：

func main() {
    var root *Node

    // 插入节点
    root = RBInsert(root, 10)
    root = RBInsert(root, 20)
    root = RBInsert(root, 30)
    root = RBInsert(root, 15)
    root = RBInsert(root, 17)
    // 继续插入其他节点...

    // 打印红黑树
    printTree(root)
}

func printTree(root *Node) {
    if root != nil {
        printTree(root.left)
        fmt.Printf("%d:%s ", root.key, root.color)
        printTree(root.right)
    }
}

这样，我们就成功通过递归和状态维护来实现了在不提供父指针的情况下进行RB-INSERT操作的红黑树实现。注意，为了简化代码，这里省略了一些边界条件检查和其他函数的具体实现部分，但核心思想是一致的。

希望这可以帮助到你！如有任何疑问，请随时提出。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

chatgpt：

在红黑树的表示中，如果不提供父指针，可以通过迭代来实现 RB-INSERT。下面是使用Go语言实现红黑树的RB-INSERT算法的示例代码：

type Node struct {
    key    int
    color  string // "RED" or "BLACK"
    left   *Node
    right  *Node
}

func RBInsert(root *Node, key int) *Node {
    newNode := &Node{key: key, color: "RED"}

    if root == nil {
        newNode.color = "BLACK"
        return newNode
    }

    var parent, current *Node

    parent = nil
    current = root

    for current != nil {
        parent = current

        if newNode.key < current.key {
            current = current.left
        } else {
            current = current.right
        }
    }

    newNode.parent = parent

    if newNode.key < parent.key {
        parent.left = newNode
    } else {
        parent.right = newNode
    }

    fixupRedBlackTree(newNode)

    return root
}

func fixupRedBlackTree(node *Node) {
	if node.parent == nil { // Case 1: The node is the root of the tree.
		node.color = "BLACK"
		return
	}

	for node.parent.color == "RED" { // Case 2 and Case 3: Parent is RED.
		if node.parent == node.parent.parent.left { // Parent is a left child.
			uncle := node.parent.parent.right

			if uncle != nil && uncle.color == "RED" { // Case 2: Uncle is also RED.
				node.parent.color = "BLACK"
				uncle.color = "BLACK"
				node.parent.parent.color = "RED"
				node = node.parent.parent
			} else { // Case 3: Uncle is BLACK or NIL.
				if node == node.parent.right {
					node = node.parent
					leftRotate(node)
				}

				node.parent.color = "BLACK"
				node.parent.parent.color = "RED"
				rightRotate(node.parent.parent)
			}
		} else { // Parent is a right child.
			uncle := node.parent.parent.left

			if uncle != nil && uncle.color == "RED" { // Case 2: Uncle is also RED.
				node.parent.color = "BLACK"
				uncle.color = "BLACK"
				node.parent.parent.color = "RED"
				node = node.parent.parent
			} else { // Case 3: Uncle is BLACK or NIL.
				if node == node.parent.left {
					node = node.parent
					rightRotate(node)
				}

				node.parent.color = "BLACK"
				node.par

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

kimi：

在红黑树的表示中，如果节点没有父指针，实现 RB-INSERT 操作会变得更加复杂，因为我们需要能够找到新插入节点的父节点以及祖先节点来执行旋转和颜色调整。以下是一个可能的方法来实现 RB-INSERT，即使没有父指针：

  1. 在插入新节点时，从根节点开始向下搜索，记录路径上的节点。这样，我们可以在需要时回溯到父节点。

  2. 在执行旋转和颜色调整时，使用这些记录的路径来找到相应的节点。

以下是 Go 语言中可能的实现策略：

package main

import (
	"fmt"
)

type Node struct {
	key   int
	color int // 0: black, 1: red
	left  *Node
	right *Node
}

type RBTree struct {
	root *Node
}

func (t *RBTree) RBInsert(key int) {
	newNode := &Node{key: key, color: 1} // 新节点着为红色

	// 从根节点开始向下搜索，记录路径
	path := []*Node{t.root}
	for path[len(path)-1] != nil {
		if key < path[len(path)-1].key {
			path = append(path, path[len(path)-1].left)
		} else {
			path = append(path, path[len(path)-1].right)
		}
	}

	// 将新节点插入到路径的最后一个节点的位置
	if key < path[len(path)-1].key {
		path[len(path)-1].left = newNode
	} else {
		path[len(path)-1].right = newNode
	}

	// 更新新节点的父指针
	newNode.parent = path[len(path)-2]

	// 修复红黑树性质
	t.fixUp(newNode)
}

func (t *RBTree) fixUp(node *Node) {
	// ...（省略修复红黑树性质的代码）
}

func (t *RBTree) rotateRight(x *Node) {
	// ...（省略右旋操作的代码）
}

func (t *RBTree) rotateLeft(x *Node) {
	// ...（省略左旋操作的代码）
}

func main() {
	tree := &RBTree{}
	keys := []int{41, 38, 31, 12, 19, 8}
	for _, key := range keys {
		tree.RBInsert(key)
	}
}

在这个实现中，我们使用了一个 path 切片来记录从根节点到新插入节点的路径。这样，当我们需要执行旋转操作时，我们可以通过这个路径来找到相应的父节点和祖先节点。

请注意，这个实现假设树是空的或者已经按照正确的红黑树性质构建的。在实际应用中，你可能需要更复杂的逻辑来处理树的初始化和节点的插入。此外，这个实现没有提供具体的旋转和颜色调整的代码，因为这些操作依赖于红黑树的特定实现细节。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

混元：

如果红黑树的表示中不提供父指针，我们可以通过其他方法来实现 RB-INSERT。以下是一种可能的实现方法：

  1. 首先，我们需要找到要插入的结点的位置。我们可以从根节点开始，沿着树的路径向下遍历，直到找到一个叶子结点，或者找到一个与要插入的结点相同的结点。

  2. 如果我们找到了一个与要插入的结点相同的结点，那么我们不需要插入新结点，因为红黑树中不允许有重复的结点。

  3. 如果我们找到了一个叶子结点，我们可以将要插入的结点作为该叶子结点的子结点插入。然后，我们需要检查插入后的树是否仍然是一棵红黑树。

  4. 为了检查插入后的树是否仍然是一棵红黑树，我们可以使用以下方法：

    a. 如果插入的结点是红色的，我们需要检查它是否违反了红黑树的性质 4。如果违反了，我们需要进行旋转和重新着色操作，直到树重新满足红黑树的性质。

    b. 如果插入的结点是黑色的，我们需要检查它是否违反了红黑树的性质 5。如果违反了，我们需要进行旋转和重新着色操作，直到树重新满足红黑树的性质。

  5. 在插入结点后，我们需要更新树的大小，并返回插入的结点。

通过以上方法，我们可以在不提供父指针的情况下实现 RB-INSERT。需要注意的是，这种方法可能会导致插入操作的时间复杂度略高，因为我们需要在插入结点后进行额外的检查和操作。但是，这种方法仍然可以保证红黑树的性质得到满足。

在这里插入图片描述

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

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

相关文章

对自动化测试断言的思考

对自动化测试断言的思考

断言在自动化测试中起着关键的作用&#xff0c;它是验证测试结果是否符合预期的重要手段。如果在自动化测试过程中忽视了断言&#xff0c;那么这个测试就失去了其本质的意义&#xff0c;因为我们无法得知测试结果是否达到了预期的效果。因此&#xff0c;断言在自动化测试中的重…
阅读更多...
【QUARTZ】springboot+quartz动态配置定时任务

【QUARTZ】springboot+quartz动态配置定时任务

Quartz 介绍 Quartz 定时任务可分为Trigger&#xff08;触发器&#xff09;、Job&#xff08;任务&#xff09;和Scheduler&#xff08;调度器&#xff09;&#xff0c;定时任务的逻辑大体为&#xff1a;创建触发器和任务&#xff0c;并将其加入到调度器中&#xff0c;如下图所…
阅读更多...
【服务器】服务器管理 - cockpit开启

【服务器】服务器管理 - cockpit开启

开启cockpit #!/bin/bashsed -i s/is():where()/is(*):where(*)/ /usr/share/cockpit/static/login.jssystemctl enable --now cockpit.socket #开启cockpit服务systemctl start cockpit.socket 登录 https://ip:9090
阅读更多...
03.分支结构

03.分支结构

分支结构 应用场景 迄今为止&#xff0c;我们写的Python代码都是一条一条语句顺序执行&#xff0c;这种代码结构通常称之为顺序结构。然而仅有顺序结构并不能解决所有的问题&#xff0c;比如我们设计一个游戏&#xff0c;游戏第一关的通关条件是玩家获得1000分&#xff0c;那…
阅读更多...
uniapp-uniCloud的基本使用（编写云存储的地区级联选择器）

uniapp-uniCloud的基本使用（编写云存储的地区级联选择器）

目录 新建项目&#xff0c;创建 uniCloud 服务空间并关联 1. 新建项目 2. 创建 uniCloud 服务空间并关联 manifest.json内未配置Appld,请重新获取后再 云数据库的使用 城市选择和云数据库 介绍 云端数据 DB Schema概述 新建项目&#xff0c;创建 uniCloud 服务空间并关…
阅读更多...
【机器学习300问】4、机器学习到底在学习什么？

【机器学习300问】4、机器学习到底在学习什么？

首先我们先了解一个前置问题&#xff0c;再回答机器学习到底在学习什么。 一、求机器学习问题有哪几步&#xff1f; 求解机器学习问题的步骤可以分为“学习”和“推理”两个阶段。首先&#xff0c;在学习阶段进行模型的学习&#xff0c;然后&#xff0c;在推理阶段用学到的模型…
阅读更多...
实现秒杀功能设计

实现秒杀功能设计

页面 登录页面 登录成功后&#xff0c;跳转商品列表 商品列表页 加载商品信息 商品详情页 根据商品id查出商品信息返回VO&#xff08;包括rmiaoshaStatus、emainSeconds&#xff09;前端根据数据展示秒杀按钮&#xff0c;点击开始秒杀 订单详情页 秒杀页面设置 后端返回秒杀…
阅读更多...
1.12 力扣中等图论

1.12 力扣中等图论

797. 所有可能的路径 - 力扣&#xff08;LeetCode&#xff09; 给你一个有 n 个节点的 有向无环图&#xff08;DAG&#xff09;&#xff0c;请你找出所有从节点 0 到节点 n-1 的路径并输出&#xff08;不要求按特定顺序&#xff09; graph[i] 是一个从节点 i 可以访问的所有节…
阅读更多...
Window Docker安装

Window Docker安装

1.下载安装Docker 在Windows上安装Docker桌面_Docker中文网 (dockerdocs.cn)https://dockerdocs.cn/docker-for-windows/install/index.html2.安装完&#xff0c;修改镜像 Docker——Windows版本Docker安装_docker windows-CSDN博客https://blog.csdn.net/weixin_51351637/ar…
阅读更多...
基于Linux的Flappy bird游戏开发

基于Linux的Flappy bird游戏开发

项目介绍 主要是使用C语言实现&#xff0c;开启C项目之旅。 复习巩固C语言、培养做项目的思维。 功能&#xff1a; 按下空格键小鸟上升&#xff0c;不按下落&#xff1b; 显示小鸟需要穿过的管道&#xff1b; 小鸟自动向右飞行&#xff1b;&#xff08;管道自动左移和创建&a…
阅读更多...
训练营第四十二天 | 01背包问题，你该了解这些！ ● 01背包问题，你该了解这些！ 滚动数组 ● 416. 分割等和子集

训练营第四十二天 | 01背包问题，你该了解这些！ ● 01背包问题，你该了解这些！ 滚动数组 ● 416. 分割等和子集

01背包问题 二维 代码随想录 dp二维数组 优化 01背包问题 一维 代码随想录 dp一维数组 416. 分割等和子集 把数组分成总和相等的两份&#xff0c;如果数组总和为奇数&#xff0c;不能分割&#xff0c;若有符合的数组子集&#xff0c;返回true 代码随想录 class Solution {p…
阅读更多...
Java内存模型之原子性

Java内存模型之原子性

文章目录 1.什么是原子性2.Java中的原子操作有哪些3.long和double的原子性4.原子操作 原子操作 ! 原子操作 1.什么是原子性 一系列的操作&#xff0c;要么全部执行成功&#xff0c;要么全部不执行&#xff0c;不会出现执行一半的情况&#xff0c;是不可分割的。 注意&#x…
阅读更多...
Android perfetto memory开源工具分析

Android perfetto memory开源工具分析

目录 原理 官网链接 下载heap_profile producer_support.cc 本地编译 push heapprofd 工具使用 pb文件获取 打开*.pb文件 trace文件 提高系统CPU性能 拆解特定函数内存占用 环境配置 工具使用 修改heap_profile 脚本 原理 Android perfetto memory分析工具和ma…
阅读更多...
Android基于Matrix绘制PaintDrawable设置BitmapShader，以手指触点为中心显示原图像圆图，Kotlin（2）

Android基于Matrix绘制PaintDrawable设置BitmapShader，以手指触点为中心显示原图像圆图，Kotlin（2）

Android基于Matrix绘制PaintDrawable设置BitmapShader&#xff0c;以手指触点为中心显示原图像圆图&#xff0c;Kotlin&#xff08;2&#xff09; 在 https://zhangphil.blog.csdn.net/article/details/135374279 基础上&#xff0c;增加一个功能&#xff0c;当手指在上面的图片…
阅读更多...
如何使用SVN查看旧版本

如何使用SVN查看旧版本

和目录 第一步&#xff1a;打开SVN客户端 第二步&#xff1a;浏览历史版本 第三步&#xff1a;还原历史版本 结论 Subversion (缩写为SVN)是一种常用的版本控制系统&#xff0c;它可以帮助团队协作开发软件项目。除了基本的版本控制功能外&#xff0c;SVN还提供了许多其他功…
阅读更多...
【已解决】如何用递归实现位运算计算两数之和

【已解决】如何用递归实现位运算计算两数之和

本博文源于笔者正在思考的如何用递归进行计算两数之和。读者一般都会想到用while循环进行操作&#xff0c;位运算两数之和的思想就犹如辗转相除法。文章并附加了对这个方法的流程演示 问题来源 想要用递归实现两数之和。 代码实现 #include<stdio.h> int add(int num…
阅读更多...
(十)IIC总线-PCF8591-ADC/DAC

(十)IIC总线-PCF8591-ADC/DAC

文章目录 IIC总线篇起始&#xff0c;终止信号应答信号发送&#xff0c;读取数据IIC通讯规则 PCF8591-ADC-DAC篇特性一般说明地址Control byte&#xff08;控制字&#xff09;简单了解一下DAC电阻分隔链应用为王DAC的应用如何设置DAC输出如何调用DAC功能 ADC的应用ADC采集特点AD…
阅读更多...
【群晖NAS】记一次FRP报错：login to server failed: connection write timeout

【群晖NAS】记一次FRP报错：login to server failed: connection write timeout

报错如下&#xff1a; rongfuDS224plus:~/fff/frp$ ./frpc -c ./frpc.toml 2024/01/12 23:08:31 [I] [root.go:139] start frpc service for config file [./frpc.toml] 2024/01/12 23:08:41 [W] [service.go:131] login to server failed: i/o deadline reached 2024/01/12 2…
阅读更多...
Java中的栈和队列操作，相互实现(力扣 232, 225)

Java中的栈和队列操作，相互实现(力扣 232, 225)

栈和队列&#xff08;Java&#xff09; Java中的 栈 & 队列 操作栈的使用队列的使用 LeetCode 232. 用栈实现队列我的代码 LeetCode 225. 用队列实现栈我的代码 Java中的 栈 & 队列 操作 栈的使用 栈的方法功能Stack()构造一个空的栈E push(E e)将e入栈&#xff0c;并…
阅读更多...
缓存学习实战篇

缓存学习实战篇

缓存练习题&#xff08;用户查询操作&#xff09; public List<ShopType> queryAllType() throws JsonProcessingException {//从缓存中查数据String shopTypeJson stringRedisTemplate.opsForValue().get("cache:shopType");//如果缓存命中&#xff0c;if (S…
阅读更多...
最新文章

Copyright @ 2022~2023