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

2024-03-19 11:36
文章标签 chatgpt 算法 ai vs 文心一言 讯飞星火 导论 218 16.2

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

六、设计算法，在O(n)时间内求解分数背包问题。如果要写代码，请用go语言。

文心一言：

分数背包问题（Fractional Knapsack Problem）是一个优化问题，其中每个物品都有一个重量和价值，目标是选择一些物品装入背包中，使得背包内物品的总价值最大，同时不超过背包的容量限制。与0-1背包问题不同，分数背包问题允许选择物品的一部分。

分数背包问题有一个贪心算法的解，其基本思想是：按照单位重量的价值（价值/重量）对物品进行排序，然后依次选择单位重量价值最高的物品，直到背包装满为止。对于最后一个物品，如果它不能完全放入背包中，我们只需放入背包剩余容量的那部分。这个算法的时间复杂度是O(n log n)，因为我们需要对物品进行排序。

然而，如果我们假设物品已经按照单位重量的价值降序排列，那么算法的时间复杂度可以降低到O(n)。在实际应用中，可能需要根据具体情况来决定是否提前对物品进行排序。

下面是使用Go语言实现的算法：

package main  import (  "fmt"  "sort"  
)  // Item represents an item with weight and value.  
type Item struct {  value, weight float64  
}  // ByUnitValue implements sort.Interface for []Item based on the unit value.  
type ByUnitValue []Item  func (a ByUnitValue) Len() int           { return len(a) }  
func (a ByUnitValue) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }  
func (a ByUnitValue) Less(i, j int) bool { return a[i].value/a[i].weight > a[j].value/a[j].weight }  // FractionalKnapsack solves the fractional knapsack problem in O(n) time.  
// It assumes that the items are already sorted by unit value in descending order.  
func FractionalKnapsack(capacity float64, items []Item) float64 {  maxValue := 0.0  currentWeight := 0.0  for _, item := range items {  if currentWeight+item.weight <= capacity {  // If the item can be added completely, add it and update the total value and weight.  maxValue += item.value  currentWeight += item.weight  } else {  // If the item can't be added completely, add only the remaining capacity's worth of it.  remainingCapacity := capacity - currentWeight  maxValue += remainingCapacity * (item.value / item.weight)  break // No need to consider further items since they have lower unit value.  }  }  return maxValue  
}  func main() {  // Example usage:  items := []Item{  {60, 10},  {100, 20},  {120, 30},  }  capacity := 50  // Sort the items by unit value in descending order.  sort.Sort(sort.Reverse(ByUnitValue(items)))  maxValue := FractionalKnapsack(float64(capacity), items)  fmt.Printf("The maximum value that can be obtained is: %.2f\n", maxValue)  
}

在这个例子中，我们首先定义了一个Item结构体来表示物品，然后定义了一个ByUnitValue类型来实现对Item切片的排序，按照单位重量的价值降序排列。FractionalKnapsack函数实现了分数背包问题的贪心算法。在main函数中，我们创建了一个物品列表，对它们进行排序，然后调用FractionalKnapsack函数来求解最大价值。

请注意，在实际应用中，如果物品没有预先排序，则排序操作（sort.Sort(sort.Reverse(ByUnitValue(items)))）将占据O(n log n)的时间。如果排序是必须的，那么整体算法的时间复杂度将是O(n log n)。如果物品已经预先按照单位重量价值排序，那么算法的时间复杂度为O(n)。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火：

分数背包问题是一种变种的背包问题，其中物品可以分割。在这个问题中，我们有一个背包和一些物品，每个物品都有一个价值和一个重量。我们的目标是选择一些物品放入背包，使得背包中的总价值最大，但是我们不能分割物品。

解决这个问题的一种方法是使用贪心算法。我们可以将所有的物品按照单位重量的价值进行排序，然后从价值最高的物品开始，尽可能多地放入背包，直到背包满为止。

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

package mainimport ("fmt""sort"
)type Item struct {value float64weight float64ratio float64
}func fractionalKnapsack(items []Item, capacity float64) float64 {sort.Slice(items, func(i, j int) bool {return items[i].ratio > items[j].ratio})totalValue := 0.0for _, item := range items {if capacity == 0 {break}amount := min(item.weight, capacity)totalValue += amount * item.ratiocapacity -= amount}return totalValue
}func min(a, b float64) float64 {if a < b {return a}return b
}func main() {items := []Item{{value: 60, weight: 10},{value: 100, weight: 20},{value: 120, weight: 30},}for i := range items {items[i].ratio = items[i].value / items[i].weight}fmt.Println(fractionalKnapsack(items, 50)) // 输出：240
}

在这个代码中，我们首先定义了一个结构体Item来表示物品，它包含了物品的价值、重量和单位重量的价值（即价值与重量的比值）。然后我们定义了一个函数fractionalKnapsack来求解分数背包问题，它接受一个物品列表和一个背包的容量作为参数，返回背包中的最大总价值。在这个函数中，我们首先将物品按照单位重量的价值进行排序，然后从价值最高的物品开始，尽可能多地放入背包，直到背包满为止。最后，我们在main函数中创建了一些物品和一个背包，然后调用fractionalKnapsack函数来求解问题。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

360智脑：

分数背包问题是一种动态规划问题，其基本思想是将物品划分为不同的分数，并在每个分数上决定是否选取该物品。为了在O(n)时间内求解分数背包问题，我们可以使用一种改进的动态规划方法，即“动态规划+贪心策略”。

以下是一个用Go语言实现的解决方案：

package mainimport "fmt"func fractionalKnapsack(weights []float64, values []float64, capacity float64) float64 {n := len(weights)// 初始化一个二维数组，用于存储每个分数上的最优解dp := make([][]float64, n+1)for i := range dp {dp[i] = make([]float64, capacity+1)}// 初始化贪婪策略选择的物品索引selected := make([]int, n+1)// 初始化最大价值maxVal := 0.0// 从最大的分数开始，向下遍历for i := n - 1; i >= 0; i-- {for j := capacity; j >= 0; j-- {if j < weights[i] {// 无法放入当前物品dp[i][j] = dp[i+1][j]} else {// 尝试放入当前物品withoutItemVal := dp[i+1][j]withItemVal := values[i] + dp[i+1][j-weights[i]]// 选择价值较大的方案if withoutItemVal < withItemVal {dp[i][j] = withItemValselected[i] = 1} else {dp[i][j] = withoutItemVal}}// 更新最大价值if dp[i][j] > maxVal {maxVal = dp[i][j]}}}// 打印背包中物品的信息fmt.Println("Selected items:")var totalWeight float64for i := 0; i < n; i++ {if selected[i] == 1 {totalWeight += weights[i]fmt.Printf("Item %d (weight: %.2f, value: %.2f)\n", i, weights[i], values[i])}}fmt.Printf("Maximum value: %.2f, Total weight: %.2f\n", maxVal, totalWeight)return maxVal
}func main() {weights := []float64{10, 20, 30}values := []float64{60, 100, 120}capacity := 50.0fractionalKnapsack(weights, values, capacity)
}

在这个解决方案中，我们首先使用动态规划方法计算出每个分数上的最优解，然后使用贪婪策略选择价值最大的物品。这种方法可以在O(n)时间内求解分数背包问题。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

智谱清言：

分数背包问题是一个典型的动态规划问题，它要求在不超过背包容量的前提下，从若干件物品中选择一些物品，使得这些物品价值的总和最大。与标准的0-1背包问题不同的是，分数背包问题通常涉及到的物品价值是分数（或小数），因此解决方案需要能够处理分数的运算。

要在O(n)时间内求解分数背包问题，通常需要采用贪心策略结合动态规划。这里给出一个使用动态规划解决分数背包问题的算法思路，但由于分数背包问题可能有多种变体，以下算法适用于最一般的情况，即物品数量和价值都是分数，并且希望找到一个分数解。

由于分数的加法可能涉及到通分，这使得直接使用动态规划处理分数变得复杂。一个可行的方法是将所有分数转换为小数来处理，计算结束后再转换回分数。这样做可以简化算法，但会失去算法的纯分数解特性。

下面是使用Go语言实现的分数背包问题的代码框架，为了简化处理，这里将所有值都转换为浮点数来处理：

package main
import ("fmt""math"
)
// Fraction 表示一个分数
type Fraction struct {Numerator intDenominator int
}
// Decimal 表示一个小数
type Decimal float64
// FractionToDecimal 将分数转换为小数
func (f Fraction) ToDecimal() Decimal {return Decimal(f.Numerator) / Decimal(f.Denominator)
}
// DecimalToFraction 将小数转换回分数
func (d Decimal) ToFraction() Fraction {// 这里仅作展示，实际上小数转分数是一个复杂问题，需要合适的精度处理return Fraction{int(d * float64(1e10)), 1e10}
}
// knapsack 分数背包问题动态规划函数
func knapsack(weights []Fraction, values []Fraction, W int) Fraction {// 初始化动态规划表dp := make([][]Decimal, len(weights)+1)for i := range dp {dp[i] = make([]Decimal, W+1)}// 填充表for i := 1; i <= len(weights); i++ {for w := 1; w <= W; w++ {// 物品i的重量大于当前背包容量，不考虑放入if weights[i-1].ToDecimal() > Decimal(w) {dp[i][w] = dp[i-1][w]} else {// 选择放入或不放入当前物品，取最大价值dp[i][w] = max(dp[i-1][w], dp[i-1][w-int(weights[i-1].ToDecimal())]+values[i-1].ToDecimal())}}}// 返回到达当前解的小数值return dp[len(weights)][W].ToFraction()
}
// max 返回两个小数中的最大值
func max(a, b Decimal) Decimal {if a > b {return a}return b
}
func main() {// 示例数据weights := []Fraction{Fraction{1, 2}, Fraction{3, 4}, Fraction{5, 6}}values := []Fraction{Fraction{1, 2}, Fraction{1, 3}, Fraction{5, 6}}W := 5// 计算分数背包问题的解result := knapsack(weights, values, W)// 输出结果fmt.Println("The maximum fraction value in the knapsack is:", result)
}

这个代码示例展示了如何使用动态规划求解分数背包问题，但请注意，这只是一个框架，实际的分数运算可能会更加复杂，需要考虑分数的通分和约分问题，以保持解的精确性。

在实际应用中，可能需要进一步的优化来确保算法在分数形式下得到精确解，而不仅仅是近似解。此外，针对具体的分数背包问题变体，算法细节可能会有

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

天工：

分数背包问题是背包问题的一种，其中每个项目（或物品）的重量和价值都是实数。这个问题比标准的整数背包问题更复杂，因为它涉及到连续值而不是离散值。

不幸的是，分数背包问题是一个NP-难问题，这意味着没有已知的可以在O(n)时间内解决它的算法。最常用的算法是动态规划，但是它的时间复杂度通常是O(n2)或O(n2 * w)，其中n是物品的数量，而w是每件物品的最大重量。这使得它不适合大规模问题。

尽管如此，如果你想要一个动态规划的解决方案，下面是一个使用Go语言实现的简单例子：

package mainimport ("fmt"
)func FractionalKnapsack(weights []int, values []float64, W int) float64 {totalValue := 0.0profit := make([]float64, len(weights))for i := range profit {profit[i] = values[i] / float64(weights[i])}sort.SliceStable(profit, func(i, j int) bool {return profit[i] > profit[j]})dp := make([][]float64, len(weights)+1)for i := range dp {dp[i] = make([]float64, W+1)}dp[0][0] = 0.0for i := 1; i <= len(weights); i++ {for wt := 0; wt <= W; wt++ {if dp[i-1][wt] > dp[i-1][wt-weights[i-1]]+profit[i-1] {dp[i][wt] = dp[i-1][wt]} else {dp[i][wt] = dp[i-1][wt-weights[i-1]] + profit[i-1]}}}return dp[len(weights)][W]
}func main() {weights := []int{3, 5, 2}values := []float64{10.5, 27, 17}W := 8 // 背包容量maxValue := FractionalKnapsack(weights, values, W)fmt.Printf("Maximum value that can be obtained is: %.2f\n", maxValue)
}

这段代码首先计算每个物品的价值密度（即单位重量的价值），然后根据这个密度对物品进行排序。然后，它使用动态规划来填充一个决策矩阵，并返回最大价值。

请注意，这个算法的时间复杂度是O(nW)，而不是O(n)。目前，没有已知的算法可以在O(n)时间内解决分数背包问题。

在这里插入图片描述

在这里插入图片描述

chatgpt：

以下是使用Go语言实现的O(n)时间复杂度求解分数背包问题的算法：

package mainimport ("fmt""sort"
)type Item struct {Weight  float64Value   float64Ratio   float64 // 单位价值Fraction float64 // 分数
}type ByRatio []Itemfunc (a ByRatio) Len() int           { return len(a) }
func (a ByRatio) Less(i, j int) bool { return a[i].Ratio > a[j].Ratio }
func (a ByRatio) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }func fractionalKnapsack(items []Item, capacity float64) float64 {sort.Sort(ByRatio(items))var totalValue float64for i := 0; i < len(items); i++ {if capacity <= 0 {break}currentWeight := items[i].WeightcurrentValue := items[i].Valueif currentWeight <= capacity {totalValue += currentValuecapacity -= currentWeightitems[i].Fraction = 1.0} else {fraction := capacity / currentWeighttotalValue += fraction * currentValuecapacity = 0items[i].Fraction = fraction}}return totalValue
}func main() {items := []Item{{2, 10, 0, 0},{3, 15, 0, 0},{5, 30, 0, 0},}capacity := 8maxTotalValue := fractionalKnapsack(items, float64(capacity))fmt.Printf("The maximum total value is: %.2f\n", maxTotalValue)
}

在上述代码中，我们定义了一个Item结构体来表示物品的重量、价值和比率。然后，我们实现了一个自定义的排序接口ByRatio，根据单位价值将物品按降序排列。接下来，我们使用贪心算法，依次选取单位价值最高的物品放入背包中，并计算总价值。最后，在main函数中初始化物品和背包容量，并调用fractionalKnapsack函数求解最大总价值。

请注意，这只是一种可能的解决方案，并不保证适用于所有情况。在实际应用中，您可能需要根据具体需求进行适当修改。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

kimi：

分数背包问题是一种特殊的背包问题，其中每个物品可以被分割成任意比例，而不是像传统的0-1背包问题那样只能完整地选择或不选择一个物品。这使得问题可以通过贪心算法在O(n)时间内解决。

在分数背包问题中，我们有n个物品，每个物品i有一个重量w_i和一个价值v_i，以及一个背包的总容量W。目标是选择物品的一部分，以使得总价值最大，同时不超过背包的总容量。

算法设计

算法的核心是按单位重量的价值对物品进行排序，然后从最高价值的物品开始，尽可能多地选择每个物品，直到达到背包的容量限制。

Go语言实现

package mainimport ("fmt"
)// Item 表示一个物品，包含其重量和价值。
type Item struct {weight intvalue  int
}// ByValuePerWeight 实现了 sort.Interface 用于按单位重量的价值排序。
type ByValuePerWeight []Itemfunc (a ByValuePerWeight) Len() int           { return len(a) }
func (a ByValuePerWeight) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByValuePerWeight) Less(i, j int) bool { return a[i].value*a[j].weight < a[j].value*a[i].weight }func fraction背包问题(items []Item, capacity int) int {// 计算每个物品的单位重量价值并排序for i := range items {items[i].value = items[i].value * items[i].weight}sort.Sort(ByValuePerWeight(items))// 初始化总价值totalValue := 0// 遍历每个物品for _, item := range items {// 如果背包容量不足以装下整个物品，则尽可能多地选择物品if capacity >= item.weight {totalValue += item.valuecapacity -= item.weight} else {// 否则，选择剩余容量的物品totalValue += capacity * item.value / item.weightbreak}}return totalValue
}func main() {items := []Item{{weight: 2, value: 10},{weight: 3, value: 20},{weight: 4, value: 30},}capacity := 10fmt.Printf("The maximum value is: %d\n", fraction背包问题(items, capacity))
}

算法正确性

这个算法的正确性基于贪心选择属性，即在每一步选择中，我们都选择当前最优的选项。在分数背包问题中，最优的选择是按单位重量的价值降序选择物品。这是因为如果存在一个比当前物品单位重量价值更高的物品，那么我们可以通过选择更多的当前物品来获得更多的价值，而不会超过背包的容量限制。

通过这种贪心选择，我们可以确保在每一步都获得最大的价值，从而在O(n)时间内找到问题的最优解。

在这里插入图片描述

在这里插入图片描述

混元：

分数背包问题是一种组合优化问题，通常用于解决在给定容量的背包中，如何选择物品以使得背包中物品的价值最大。与0/1背包问题不同，分数背包问题允许将物品分割为任意部分。

在O(n)时间内求解分数背包问题是不可能的，因为这将破坏该问题的NP-hard性质。然而，我们可以使用贪心算法在O(nlogn)时间内求解分数背包问题。以下是使用Go语言实现的贪心算法：

package mainimport ("fmt""sort"
)type Item struct {value float64weight float64
}type ByValuePerWeight []Itemfunc (a ByValuePerWeight) Len() int           { return len(a) }
func (a ByValuePerWeight) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByValuePerWeight) Less(i, j int) bool { return a[i].value/a[i].weight > a[j].value/a[j].weight }func fractionalKnapsack(items []Item, capacity float64) float64 {sort.Sort(ByValuePerWeight(items))totalValue := 0.0for _, item := range items {if capacity >= item.weight {totalValue += item.valuecapacity -= item.weight} else {totalValue += item.value * (capacity / item.weight)break}}return totalValue
}func main() {items := []Item{{value: 60, weight: 10},{value: 100, weight: 20},{value: 120, weight: 30},}capacity := 50.0value := fractionalKnapsack(items, capacity)fmt.Printf("最大价值: %.2f\n", value)
}

这个算法首先根据单位重量的价值对物品进行排序，然后从最有价值的物品开始，尽可能多地放入背包。当背包容量不足以容纳整个物品时，我们只取部分物品。这种方法在O(nlogn)时间内求解分数背包问题，但不能保证得到最优解。

在这里插入图片描述

在这里插入图片描述

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


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

相关文章

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