文心一言 VS 讯飞星火 VS chatgpt （251）-- 算法导论18.2 4题

2024-05-04 04:04
文章标签 chatgpt 算法 ai vs 251 文心一言 讯飞星火 导论 18.2

本文主要是介绍文心一言 VS 讯飞星火 VS chatgpt （251）-- 算法导论18.2 4题，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

四、假设关键字 {1，2，…，n} 被插入一棵最小度数为 2 的空 B 树中，那么最终的B树有多少个结点？如果要写代码，请用go语言。

文心一言：

B树（B-tree）是一种自平衡的树，常用于数据库和文件系统的索引结构。在B树中，每个节点最多有 m 个子节点（对于B树，m 是阶数，即节点的最大子节点数），并且每个非根节点至少有 ⌈m/2⌉ 个子节点（其中 ⌈x⌉ 表示不小于 x 的最小整数）。

对于最小度数为2的B树（通常表示为B_2树），每个节点最多有3个子节点（因为 m = 2*2 - 1 = 3），并且每个非根节点至少有2个子节点。

现在，考虑将关键字 {1, 2, …, n} 插入一个最小度数为2的空B树中。由于B树的性质，节点中的关键字数量将是 ⌈m/2⌉ - 1 到 m - 1 之间，即1到2个关键字对于内部节点，而对于叶子节点，由于它们是外部节点，它们可以包含从 ⌈m/2⌉ - 1 到 m 个关键字，即1到3个关键字。

由于我们不知道具体的 n 值，我们无法给出一个确切的节点数，但我们可以根据B树的性质来估算。在最坏的情况下（即B树尽可能地“填满”），内部节点将尽可能多地包含2个关键字，而叶子节点将尽可能多地包含3个关键字。

但是，为了得到精确的节点数，我们需要实际地模拟B树的插入过程。由于这涉及到B树操作的复杂性，这里只提供一个大致的算法思路，而不是完整的Go代码实现。

算法思路：

初始化一个空的B_2树，只有一个根节点（并且没有关键字）。
遍历关键字集合 {1, 2, …, n}，对于每个关键字：
尝试将其插入到B树中。
如果插入导致节点分裂，处理分裂并将一些关键字上推到父节点（如果父节点已满，则可能进一步分裂和上推）。
重复这个过程，直到根节点也可能分裂（这会导致一个新的根节点被创建）。
计数B树中的节点数。
Go语言实现B树通常涉及定义节点结构和实现插入、分裂等操作的函数。由于这超出了简单的文本回答范围，我无法在这里给出完整的Go代码。但是，你可以根据上面的算法思路来设计和实现你的B树代码。

如果你对B树的实现细节感兴趣，我建议你查阅相关的数据结构和算法教材或在线资源，以获取更详细的信息和示例代码。

讯飞星火：

在一棵最小度数为2的B树中，每个节点最多可以有2个子节点。因此，当我们插入关键字时，如果当前节点未满（即子节点数量少于2），我们可以直接将关键字插入该节点。否则，我们需要将当前节点分裂成两个节点，并将其中一个作为新节点插入到父节点中。

为了计算最终的B树中的节点数量，我们可以使用递归方法。首先，我们将根节点视为一个单独的节点。然后，对于每个关键字，我们将其插入到根节点中。如果根节点已满，则将其分裂成两个新节点，并将其中一个作为新节点插入到父节点中。重复这个过程，直到所有关键字都被插入到B树中。

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

package mainimport ("fmt"
)type Node struct {Keys  []intChild []*Node
}func NewNode() *Node {return &Node{Keys:  make([]int, 0),Child: make([]*Node, 0),}
}func (n *Node) IsFull() bool {return len(n.Keys) == 2
}func (n *Node) Insert(key int) {if n.IsFull() {// Split the node and insert the key into the appropriate child nodenewNode := NewNode()n.Child = append(n.Child, newNode)index := 0for index < len(n.Keys) && key > n.Keys[index] {index++}if index == len(n.Keys) {newNode.Insert(key)} else {n.Keys = append(n.Keys[:index], append([]int{key}, n.Keys[index:]...)...)}} else {index := 0for index < len(n.Keys) && key > n.Keys[index] {index++}n.Keys = append(n.Keys[:index], append([]int{key}, n.Keys[index:]...)...)}
}func (n *Node) CountNodes() int {count := 1for _, child := range n.Child {count += child.CountNodes()}return count
}func main() {bTree := NewNode()keys := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}for _, key := range keys {bTree.Insert(key)}fmt.Println("Number of nodes in B-tree:", bTree.CountNodes())
}

这段代码首先定义了一个表示B树节点的结构体Node，并实现了NewNode、IsFull、Insert和CountNodes等方法。然后在main函数中创建了一个空的B树，并插入了一系列关键字。最后，调用CountNodes方法计算B树中的节点数量，并输出结果。

360智脑：

首先，我们需要明确B树的概念。B树是一种自平衡树，与AVL树和红黑树不同，B树允许非叶子节点有指向关键字的指针，这意味着每个节点可以拥有多个子节点。B树的最小度数t是指每个节点至少拥有的子节点数。

在这个问题中，关键字集合{1, 2, …, n}被插入到一棵最小度数为2的空B树中。这意味着每个非叶子节点都有至少2个子节点。我们将通过一个简单的归纳过程来计算最终的B树结点总数。

基础情况：
当n = 1时，B树只有一个根节点，包含关键字1，总共有1个结点。

归纳步骤：
假设当n = k时，B树有a(k)个结点。现在考虑将n = k+1时的关键字插入到这个B树中。因为B树的最小度数为2，所以每个非叶子节点都有至少2个子节点。这意味着在插入k+1个关键字后，每个非叶子节点都至少分裂过一次，导致树的高度增加了1。具体来说，插入第k+1个关键字后，树的最右分支增加了一个新的度为1的节点（包含关键字k+1）和一个新的度为0的叶子节点。因此，总的节点数增加了1。

所以，当n = k+1时，B树的结点总数为a(k) + 1。

通过这个递推关系，我们可以得出B树的结点总数为：

a(n) = a(n-1) + 1

这意味着每次插入一个新关键字，结点总数就增加1。因此，对于n个关键字，最终的B树有n个结点。

下面是一个简单的Go语言代码示例来模拟这个插入过程并计算B树的结点总数：

package mainimport "fmt"func bTreeInsert(root **Node, key int) {// 如果树为空，创建一个新的节点if *root == nil {*root = newNode(key)return}// 如果节点不为空，递归插入if key < (*root).key {bTreeInsert(&(*root).left, key)} else if key > (*root).key {bTreeInsert(&(*root).right, key)} else {// Key already present in tree, no need to insertreturn}
}type Node struct {key   intleft  *Noderight *Node
}func newNode(key int) *Node {return &Node{key: key}
}func main() {var root *Nodefor i := 1; i <= 10; i++ {bTreeInsert(&root, i)}fmt.Println("Total number of nodes in the B-tree:", countNodes(root))
}func countNodes(root *Node) int {if root == nil {return 0}return 1 + countNodes(root.left) + countNodes(root.right)
}

请注意，上述代码是一个简化的B树插入示例，它假设B树的每个节点只存储一个关键字，并且没有考虑B树的其他特性，如多路性。这只是一个基本的演示如何使用Go语言来构建和遍历B树的示例。在实际应用中，B树的实现会更加复杂。

智谱清言：

B树是一种自平衡的树，它的每个结点都包含一定数量的键（或者关键字）和子结点指针。每个结点除了根结点外，都至少包含两个子结点。B树的最小度数（t）决定了树的结构。对于最小度数为2的B树，每个结点至少有两个子结点。

当关键字 {1，2，…，n} 被插入一个最小度数为2的空B树时，每个结点在插入过程中会尽可能地保持平衡，即每个结点在插入新元素后，如果结点的子结点数量大于等于t，则不会发生分裂。但如果子结点数量小于t-1，则可能会发生分裂。

对于最小度数为2的B树，插入第一个元素时，根结点只有一个元素；插入第二个元素时，根结点会分裂成两个结点，其中一个结点有一个元素，另一个结点有两个元素；插入第三个元素时，可能会触发其中一个结点的再次分裂，以此类推。

因此，问题可以转化为求解将n个元素插入到最小度数为2的B树中，根结点分裂的次数。

在Go语言中，我们可以使用如下代码来估算这个B树最终的结点数量：

package main
import ("fmt"
)
// 计算B树的结点数量
func bTreeNodeCount(n int) int {// 初始化根结点root := &bTreeNode{elements: []int{1},children: []*bTreeNode{},}return insertElements(root, []int{2, 3, 4}, n)
}
// B树结点结构
type bTreeNode struct {elements []intchildren []*bTreeNode
}
// 插入元素到B树
func insertElements(node *bTreeNode, elements []int, n int) int {// 插入元素for _, elem := range elements {node.elements = append(node.elements, elem)n--// 检查是否需要分裂if n == 0 || len(node.elements)>=2{// 分裂结点splitNode(node)// 递归插入剩余元素n = bTreeNodeCount(n)node = node.children[0]}}return n
}
// 分裂B树结点
func splitNode(node *bTreeNode) {// 创建新结点newNode := &bTreeNode{elements: node.elements[len(node.elements)/2:],children: []*bTreeNode{},}// 移除分割元素node.elements = node.elements[:len(node.elements)/2]// 添加新结点到子结点列表node.children = append(node.children, newNode)// 调整新结点的子结点if len(newNode.elements) > 1 {newNode.children = append(newNode.children, &bTreeNode{elements: newNode.elements[:len(newNode.elements)/2],children: []*bTreeNode{},})newNode.elements = newNode.elements[len(newNode.elements)/2:]}if len(node.elements) > 1 {node.children = append(node.children, &bTreeNode{elements: node.elements[len(node.elements)/2:],children: []*bTreeNode{},})node.elements = node.elements[:len(node.elements)/2]}
}
func main() {n := 1000 // 假设我们有1000个元素count := bTreeNodeCount(n)fmt.Printf("最终的B树有 %d 个结点\n", count)
}

这段代码模拟了将关键字 {1，2，…，n} 插入最小度数为2的B树的过程，并计算最终B树的结点数量。需要注意的是，这里的

天工：

首先，我们来确定插入关键字{1, 2, …, n} 到一个最小度为2的B树中后，该B树的结构。

由于B树的最小度为2，这意味着除了根结点以外，每个非叶子结点至少有2个孩子结点。因此，我们可以推断出，当我们将n个元素插入到这样的B树中时，树的高度不会超过log2(n/2+1)，因为在完全情况下，树的高度等于log2(n/2+1)。

现在，让我们来确定这个B树的具体结构。对于最小度为2的B树，我们可以得出以下结论：

  • 如果n = 1，树的结构将是一个单独的根节点，包含一个键值对 (1) 和两个指针（分别指向空子树）。
  • 如果 n > 1，树的结构将由多个层次组成。在这种情况下，根节点至少包含一个键值对，并且可能包含更多的键值对，取决于子节点的数量和键值的分布。

为了计算插入n个元素后的B树中的总节点数，我们可以使用递归关系。假设f(h)表示高度为h的B树中的总节点数（包括根节点）。那么，对于一个高度为 h+1 的B树，它的总节点数将是 f(h) + f(h-1) * 2 - 1，其中 f(h-1) * 2 - 1 表示从高度 h-1 的 B树中分离出的两个子树各自增加了一个节点（因为每个非叶子结点至少有2个孩子结点）。

现在让我们来看看如何使用 Go 语言来实现这个算法。

package mainimport "fmt"// 计算插入n个元素后的最小度为2的B树中的总节点数
func calculateTotalNodes(n int) int {if n == 0 {return 0}height := int(math.Floor(math.Log2((float64(n)/2)+1)))totalNodes := 1 // 根节点for i := 0; i < height; i++ {// 每一层的节点数都是前一层的节点数加上前一层的节点数乘以2再减去1// 因为每一层都会从上一层分离出两个子树，每一个子树都会增加一个节点totalNodes += (totalNodes*2 - 1)}return totalNodes
}func main() {n := 10 // 可以修改n为其他值进行测试fmt.Println("For n =", n, "the total number of nodes in a B tree of order 2 is:", calculateTotalNodes(n))
}

注意：上述代码中的 math.Floor 和 math.Log2 函数分别用于向下取整和以2为底的对数计算，这些函数在 Go 语言的 math 包中提供。此外，由于Go语言没有内置的大数支持，所以当处理非常大的n值时，可能需要使用其他库来处理大数运算。

灵小智：

在一个最小度数为2的空B树中，节点的数量取决于输入关键字的数量n。

B树有以下几个特点：

1.根节点至少有两个子节点。

2.除了根节点和叶子节点外，每个节点至少有t-1个关键字（t为最小度数）。

3.所有叶子节点都位于同一层级。

对于一个空的B树，所有关键字都作为叶子节点插入。由于最小度数为2，每个节点至少有一个关键字和两个孩子指针。因此，每个叶子节点能容纳的关键字数量为2-1=1。

假设输入关键字数量为n，在B树中最多需要n个叶子节点来容纳这些关键字。每个叶子节点至少包含一个关键字，因此B树中的节点数量至少为n个。

另外，根据B树的特点，在插入过程中，可能会出现节点 ** 的情况，即一个节点中的关键字数量超过了上限。当节点 ** 时，B树的节点数量会增加。但是，在一个空的B树中，所有的关键字都是作为叶子节点插入的，不存在节点 ** 的情况。

因此，在一个最小度数为2的空B树中，最终的B树节点数量为n。

chatgpt：

在一个最小度数为 2 的B树中，每个非根内部节点至少包含2个孩子（子节点），根节点至少有2个孩子，因此每个节点至少包含1个键。每个节点包含的键的数量介于 t-1 和 2t-1 之间，其中 t 是B树的最小度数。

假设有 n 个关键字需要插入B树中。对于一个B树，我们可以计算节点数的上界：

  • 根节点至少有一个键和两个孩子。
  • 第二层的节点至少有一个键和两个孩子。
  • 对于高度为 h 的树，每个节点除了根节点以外都至少包含 t-1 个键和 t 个孩子。

因此，通过这种方式，我们可以计算B树中节点的上界个数。

下面是用Go语言实现计算B树中节点数的代码：

package mainimport ("fmt""math"
)func calculateNodes(n, t int) int {upperBound := 1 // 根节点currentLevelNodes := 1for currentLevelNodes < n {upperBound += int(math.Ceil(float64(currentLevelNodes) / float64(t-1))) * tcurrentLevelNodes *= t}return upperBound
}func main() {n := 10  // 假设关键字为 {1,2,...,n}t := 2   // B树的最小度数为 2nodesCount := calculateNodes(n, t)fmt.Printf("B树中共有 %d 个节点\n", nodesCount)
}

在这个代码示例中，我们定义了calculateNodes函数来计算B树中节点的上界个数。在main函数中，我们假设有10个关键字需要插入到B树中，最小度数为2，然后计算B树的节点个数并输出结果。

您可以根据需要调整n和t的值，以查看不同情况下B树中节点的数量。

在这里插入图片描述

在这里插入图片描述

kimi：

在最小度数为 2 的 B 树中，每个内部节点（除了根节点）至少有 2 个键值和 3 个子节点（因为每个键值对应一个子节点）。为了确定插入关键字 {1, 2, …, n} 后 B 树的节点总数，我们需要考虑 B 树的构建规则。

对于最小度数为 2 的 B 树，每个内部节点可以有的键值数量范围是 [2, 4]。当节点达到最大键值数量时，它会分裂成两个节点，每个节点包含一半的键值，并且中间的键值提升到父节点中。

根节点可以有 1 个键值（如果它是唯一的节点）或者至少 2 个键值（如果树中有其他节点）。当根节点分裂时，B 树的高度会增加。

为了简化计算，我们可以考虑最满的情况，即每个内部节点都有 4 个键值和 5 个子节点。在这种情况下，每个节点的键值数量最大化，因此节点数量最小化。

假设 B 树的高度为 h，那么根节点有 2 个键值，其他每层有 2^(h-1) 个节点，每层的节点都有 4 个键值。由于每个节点有 4 个键值，所以除了根节点外，树中总共有 (n - 2) / 4 个内部节点的键值。因此，我们可以建立以下等式来计算高度 h：

2 + 4 * (2^(h-2)) >= n

解这个不等式，我们可以找到满足条件的最小高度 h。然后，我们可以计算节点总数，节点总数是所有层的节点数之和，加上根节点：

节点总数 = 1（根节点）+ 2^1 + 2^2 + ... + 2^(h-1)

这是一个等比数列求和的问题，解为：

节点总数 = 1 + 2 * (1 - 2^h) / (1 - 2)

由于我们要找的是最终的 B 树有多少个节点，我们可以用 Go 语言来编写代码计算高度 h，然后计算节点总数：

package mainimport ("fmt""math"
)// 计算 B 树的高度
func calculateHeight(n int) int {height := 1for 2*(1<<height) < n {height++}return height
}// 计算 B 树的节点总数
func calculateTotalNodes(n int) int {height := calculateHeight(n)return int(1 + 2*(1-math.Pow(2, float64(height)))/(float64(1-2)))
}func main() {n := 7 // 示例，插入关键字的数量totalNodes := calculateTotalNodes(n)fmt.Printf("The total number of nodes in the B-Tree after inserting %d keys is: %d\n", n, totalNodes)
}

在这个 Go 语言程序中，calculateHeight 函数计算插入 n 个关键字后 B 树所需的最小高度。calculateTotalNodes 函数计算 B 树的节点总数。然后在 main 函数中，我们设置插入的关键字数量 n，并调用这些函数来计算节点总数。

在这里插入图片描述

在这里插入图片描述

混元：

在最小度数为 2 的 B 树中插入关键字 {1, 2, …, n} 时，每个节点最多可以有 2 个子节点

  1. 当 n = 1 时，只有一个关键字，所以只需要一个节点。
  2. 当 n = 2 时，有两个关键字，可以将它们放入同一个节点。
  3. 当 n > 2 时，每个节点可以包含 1 个关键字和 2 个子节点。因此，我们可以将关键字分成 ceil(n/2) 组，每组包含 2 个关键字（除了最后一组可能只有 1 个关键字）。这样，我们可以得到 ceil(n/2) 个节点。

以下是使用 Go 语言实现的函数，用于计算在最小度数为 2 的 B 树中插入关键字 {1, 2, …, n} 时的节点数量：

package mainimport ("fmt""math"
)func countNodesInBTree(n int) int {if n == 1 {return 1}if n == 2 {return 1}return int(math.Ceil(float64(n) / 2.0))
}func main() {fmt.Println(countNodesInBTree(1)) // 输出 1fmt.Println(countNodesInBTree(2)) // 输出 1fmt.Println(countNodesInBTree(3)) // 输出 2fmt.Println(countNodesInBTree(4)) // 输出 2fmt.Println(countNodesInBTree(5)) // 输出 3
}

这个函数接受一个整数 n 作为输入，表示关键字的数量，并返回一个整数，表示最终的 B 树中的节点数量。

在这里插入图片描述

在这里插入图片描述

这篇关于文心一言 VS 讯飞星火 VS chatgpt （251）-- 算法导论18.2 4题的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/958296。

相关文章

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
AI绘图怎么变现？想做点副业的小白必看！

AI绘图怎么变现？想做点副业的小白必看！

在科技飞速发展的今天，AI绘图作为一种新兴技术，不仅改变了艺术创作的方式，也为创作者提供了多种变现途径。本文将详细探讨几种常见的AI绘图变现方式，帮助创作者更好地利用这一技术实现经济收益。 更多实操教程和AI绘画工具，可以扫描下方，免费获取 定制服务：个性化的创意商机 个性化定制 AI绘图技术能够根据用户需求生成个性化的头像、壁纸、插画等作品。例如，姓氏头像在电商平台上非常受欢迎，
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
从去中心化到智能化：Web3如何与AI共同塑造数字生态

从去中心化到智能化：Web3如何与AI共同塑造数字生态

在数字时代的演进中，Web3和人工智能（AI）正成为塑造未来互联网的两大核心力量。Web3的去中心化理念与AI的智能化技术，正相互交织，共同推动数字生态的变革。本文将探讨Web3与AI的融合如何改变数字世界，并展望这一新兴组合如何重塑我们的在线体验。 Web3的去中心化愿景 Web3代表了互联网的第三代发展，它基于去中心化的区块链技术，旨在创建一个开放、透明且用户主导的数字生态。不同于传统
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...
AI一键生成 PPT

AI一键生成 PPT

AI一键生成 PPT 操作步骤 作为一名打工人，是不是经常需要制作各种PPT来分享我的生活和想法。但是，你们知道，有时候灵感来了，时间却不够用了！😩直到我发现了Kimi AI——一个能够自动生成PPT的神奇助手！🌟 什么是Kimi？ 一款月之暗面科技有限公司开发的AI办公工具，帮助用户快速生成高质量的演示文稿。 无论你是职场人士、学生还是教师，Kimi都能够为你的办公文
阅读更多...
csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

这是一道扩展欧几里得算法的简单应用题，这题是在湖南多校训练赛中队友ac的一道题，在比赛之后请教了队友，然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意：把题意转变下就变成了：求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点：求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个
阅读更多...
Andrej Karpathy最新采访：认知核心模型10亿参数就够了，AI会打破教育不公的僵局

Andrej Karpathy最新采访：认知核心模型10亿参数就够了，AI会打破教育不公的僵局

夕小瑶科技说 原创  作者 | 海野 AI圈子的红人，AI大神Andrej Karpathy，曾是OpenAI联合创始人之一，特斯拉AI总监。上一次的动态是官宣创办一家名为 Eureka Labs 的人工智能+教育公司 ，宣布将长期致力于AI原生教育。 近日，Andrej Karpathy接受了No Priors（投资博客）的采访，与硅谷知名投资人 Sara Guo 和 Elad G
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2