数据结构与算法之排序: 桶排序 (Ts, Py, Go版)

FFmpeg实战:SEI自定义数据在RTMP推流中的高效嵌入 本文深入探讨了如何利用FFmpeg在RTMP推流中高效嵌入SEI自定义数据。通过将SEI比作与视频帧同步的“小纸条”,文章详细解析了H.264码流中SEI的结构与位置,并提供了命令行与API编程两种实战方法,帮助开发者实现直播答题、AI元数据回传等场景下的帧级精准数据同步。 阅读详情

排序

  • 排序:把某个乱序的数组变成升序或降序的数组 (这里用数组来做举例)

桶排序

  • 根据元素的取值范围,创建多个桶, 每个桶代表一个区间范围
    • 创建桶的数量和范围需要尽可能保证元素能够被均匀分布
  • 接下来将元素放进对应的桶中,分别对每个桶中的元素进行排序
    • 桶内采用的排序算法可自行决定
    • 均匀分布后,每个桶内元素数量不会很多
  • 最后,按顺序将桶里的元素取出就完成了排序
  • 桶排序用的并不多,主要体现在对于桶排序的应用: 计数排序和基数排序
  • 核心思想
    • 基于最小值和最大值算出一个差值,基于差值确定桶的数量和范围
    • 之后遍历数组中的每个元素,来分配到不同的桶中
    • 对每一个桶进行单独的排序
    • 最后整合所有的桶,即可

Typescript 版算法实现


1 )定义桶数,均匀分布

// 获取当前在第几个桶里
function getIndex(period: number, currentDist: number) {
	if (currentDist <= period) return 0;
	return Math.floor(currentDist / period);
}

// 桶排序 主函数 list 待排序数组, n是定义的桶数量
function bucketSort(list: number[], n: number = 2) {
  // 计算最大值和最小值
  const max: number = Math.max.apply(null, list);
  const min: number = Math.min.apply(null, list);
  const dist: number = max - min; // 最大值和最小值两者差距
  let buckets: number[][] = []; // 用于存放多个桶的总数组
  // n个桶, 每个桶内存放范围 dist / n 每个桶的间隔
  const period: number = Math.ceil(dist / n);
  // 将列表中的数据分配到不同的桶里
  list.forEach((current: number) => {
    const d: number = current - min; // 当前与最小值的差距,用于计算当前数据应该填充在哪个桶内
    const index: number = getIndex(period, d); // 基于桶数和当前值,算出应该存放到第几个桶内
    // 基于 index 来填充到对应的桶内
    !buckets[index] ? (buckets[index] = [current]) : buckets[index].push(current);
  });
  // 对 buckets 中的每个桶进行排序
  buckets = buckets.map((bucket: number[]) => {
    bucket.sort((a: number, b: number) => a - b); // 这个使用默认的排序,其实内部可以使用任意的排序算法
    return bucket;
  });
  // 对 buckets 中的每个桶进行合并 (拍平)
  /*
  const result = buckets.toString().split(',');
  return result.map(item => Number(item));
  */
  // 可能桶内存在空元素的桶被过滤掉,之后拍平处理
  const result = buckets.filter(bucket => bucket).flat();
  return result;
}

const list = [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102];
const result = bucketSort(list, 5);
console.log(result); // [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]

Python3 版算法实现


1 ) 方案1

def get_index(period, current_dist):
    if current_dist <= period:
        return 0
    return current_dist // period

def bucket_sort(lst, n=2):
    if len(lst) < 2:
        return lst

    # 计算最大值和最小值
    max_val = max(lst)
    min_val = min(lst)
    dist = max_val - min_val  # 最大值和最小值的差距
    if dist == 0:
        return lst  # 如果所有元素都相同,直接返回

    # 初始化桶数组,确保有足够的桶
    buckets = [[] for _ in range(n)]

    # 计算每个桶的间隔
    period = (dist + 1) // n

    # 将列表中的数据分配到不同的桶里
    for current in lst:
        d = current - min_val  # 当前与最小值的差距
        index = get_index(period, d)  # 基于桶数和当前值,算出应该存放到第几个桶内
        if index >= n:
            index = n - 1  # 确保索引不超过桶数组的范围
        buckets[index].append(current)

    # 对 buckets 中的每个桶进行排序
    for bucket in buckets:
        bucket.sort()  # 可以使用任意的排序算法

    # 对 buckets 中的每个桶进行合并 (拍平)
    result = [item for sublist in buckets for item in sublist]
    return result

def test_bucket_sort():
    test_cases = [
        [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102],  # 一般情况
        [5, 4, 3, 2, 1],  # 逆序
        [1, 2, 3, 4, 5],  # 已经有序
        [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5],  # 随机顺序
        [],  # 空数组
        [1],  # 单元素数组
        [-2, 1, 0, -9, 1, 3, 9, 99, 9, -30, -100, 100, 88, 88, 20, 1, 0, 3, 4, 5, -20],  # 复杂情况
    ]

    for test_case in test_cases:
        copy_list = test_case[:]
        sorted_list = bucket_sort(copy_list, 5)
        print(f"Original: {test_case}, Sorted: {sorted_list}")

if __name__ == "__main__":
    test_bucket_sort()

Golang 版算法实现


1 ) 方案1

package main

import (
	"fmt"
	"math"
	"sort"
)

// 获取当前在第几个桶里
func getIndex(period int, currentDist int) int {
	if currentDist <= period {
		return 0
	}
	return currentDist / period
}

// 桶排序 主函数 list 待排序数组, n是定义的桶数量
func bucketSort(list []int, n int) []int {
	if len(list) < 2 {
		return list
	}

	// 计算最大值和最小值
	maxVal := list[0]
	minVal := list[0]
	for _, num := range list {
		if num > maxVal {
			maxVal = num
		}
		if num < minVal {
			minVal = num
		}
	}
	dist := maxVal - minVal // 最大值和最小值的差距
	if dist == 0 {
		return list // 如果所有元素都相同,直接返回
	}

	// 初始化桶数组,确保有足够的桶
	buckets := make([][]int, n)

	// 计算每个桶的间隔
	period := int(math.Ceil(float64(dist) / float64(n)))

	// 将列表中的数据分配到不同的桶里
	for _, current := range list {
		d := current - minVal        // 当前与最小值的差距
		index := getIndex(period, d) // 基于桶数和当前值,算出应该存放到第几个桶内
		if index >= n {
			index = n - 1 // 确保索引不超过桶数组的范围
		}
		buckets[index] = append(buckets[index], current)
	}

	// 对 buckets 中的每个桶进行排序
	for _, bucket := range buckets {
		sort.Ints(bucket) // 可以使用任意的排序算法
	}

	// 对 buckets 中的每个桶进行合并 (拍平)
	var result []int
	for _, bucket := range buckets {
		result = append(result, bucket...)
	}
	return result
}

func testBucketSort() {
	testCases := [][]int{
		{102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102}, // 一般情况
		{5, 4, 3, 2, 1},                   // 逆序
		{1, 2, 3, 4, 5},                   // 已经有序
		{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}, // 随机顺序
		{},                                // 空数组
		{1},                               // 单元素数组
		{-2, 1, 0, -9, 1, 3, 9, 99, 9, -30, -100, 100, 88, 88, 20, 1, 0, 3, 4, 5, -20}, // 复杂情况
	}

	for _, testCase := range testCases {
		copyList := make([]int, len(testCase))
		copy(copyList, testCase)
		sortedList := bucketSort(copyList, 5)
		fmt.Printf("Original: %v, Sorted: %v\n", testCase, sortedList)
	}
}

func main() {
	testBucketSort()
}

总结

  • 桶排序的时间复杂度 在 O(n) ~ O(n2n^2n2)
  • 普通桶排序并不普遍应用是拆分为桶后,在每个桶内还需要排序,意义就不大了
    • 而且要考虑每个桶内用什么样的数据结构来存储(考虑到内部排序)
      • 如果还用数组就极大浪费了空间(需使用最大的空间, 不同语言有区别)
      • 一般可以使用链表,但是对链表排序又开始麻烦了
    • 桶排序优化空间,时间上就会增加;优化时间空间上又会增多, 取一个时间和空间的平衡
  • buckets.map 基本是常数级别,这里实际上不怎么会消耗时间, 具体的sort算法可以使用任意的排序算法实现
  • 关于怎么处理和分配桶,上述算法基于用户自行填入的桶数,来均匀处理, 也可传入所有桶的范围分布列表
  • 那算法的细节实现就会不一样,但基本思想是一致的
  • 虽然上述算法意义不大, 但是桶排序的意义在于其思想:分而治之, 分配处理, 桶作为基本单位
  • 这个桶排序算法在开发中是比较重要的一种思想
YOLOv11改进 - 卷积Conv | SPD-Conv空间深度转换卷积优化空间信息编码,攻克小目标检测难题 本文介绍了一种名为SPD-Conv的新型CNN构建块及其在YOLOv11中的结合。传统CNN在处理低分辨率图像或小物体时,因使用步长卷积和池化层导致细粒度信息丢失、性能下降。SPD-Conv由空间到深度(SPD)层和非步长卷积(Conv)层组成,完全消除卷积步长和池化层,避免信息损失。SPD层重排特征图元素将空间信息转换到深度维度,非步长卷积层进一步处理特征图。我们将SPD-Conv集成进YOLOv11,实验证明其在低分辨率图像和小物体检测任务上显著优于现有模型。 阅读详情

相关推荐

wpa_supplicant EAPOL状态机分析

wpa_supplicant EAPOL状态机分析

加油鸭 1477

[算法] 计数排序/桶排序/基数排序 golang 详解

计数排序/桶排序/基数排序 golang 详解 都是使用桶 bucket (额外的空间)将有限范围(比如100) arr 映射到一个数组里面 然后遍历 bucket 拿到数据依次摆放 下面是计数排序的动图 桶排序和奇数排序都可以一个位置储存多个范围的value 计数排序 //计数排序 func CountingSort2(arr []int) { //参数处理 if len(arr) == 0 { fmt.Printf("%s\n", "err: len(arr) == 0") retur

半亩方糖 1009

Android Settings 设置Preference置灰显示

使Preference置灰显示,不能点击。先调用Preference的setEnabled(false),再调用setShouldDisableView(true); 如果使置灰项恢复正常可点击,可调用setEnabled(true)。

随风而动 1050

数据结构与算法之排序: LeetCode 164. 最大间距 (Ts, Py, Go版)

1 )借用原生sort + 迭代取相邻最大值。2 )基数排序来解 3 )计数排序来解 4 )桶排序

Wang的专栏 402

双传声器法测量吸声材料的吸声系数(公式推导与解释)

在双传声器法中,通过测量两个位置的声压 p1和 p2​,可以分离出入射波和反射波的声压分量。双传声器法一般在阻抗管中进行,阻抗管的一端为平面波声源,另一端放置待测材料。两个传声器放置在靠近材料的阻抗管内,用于测量管道内的声压。双传声器法是一种常用于测量材料吸声系数的实验方法,通过在管道内使用两个传声器测量声波的入射和反射,来计算出材料的吸声系数。当测试样品较少时,测试时,需要交换两个传声器的位置,目的是为了相位校准。

m0_57407372的博客 1876

Accelstepper 库中的参数计算公式

要完全调试电机的各个参数,例如最大速度,加速度等,就需要了解其计算公式和原理。 以下是代码注释: /// This code uses speed calculations as described in /// "Generate stepper-motor speed profiles in real time" by David Austin/// http://fab.cba.mi...

wenguitao的博客 4457

数据结构与算法之排序: 基数排序 (Ts, Py, Go版)

基数排序时间复杂度 O(kn) ≈ O(n) k是常数最外层的 max/base 是常数级别, 内部的多个for循环也是常数,即: 常数 k基数排序也可理解为按关键字(这里的关键字就是基数radix)排序非比较排序,基于下标的顺序来回赋值, 使用计数排序的思想做累加数组基数排序基于计数排序,是桶排序的一种, 又称多关键字排序最好从个位(低位)先开始排起,这是一种比较简单的处理方式高位优先需要用到递归,就复杂一些是一种思想简单,实现起来有些复杂的算法。

Wang的专栏 349

8台 × 8卡 910B NPU之顶尖大模型选型分析

本文对比了2026年主流大语言模型在昇腾910B NPU集群上的部署方案。重点评估了GLM5、MiniMax M2.5、Kimi K2.5、DeepSeek V3.2和Qwen 3.5旗舰版等候选模型,从部署需求(显存占用)、能力表现(基准测试、多模态支持)和NPU生态适配度三个维度进行分析。结果显示DeepSeek V3.2综合表现最优:支持BF16/W8A8/INT4量化,在4TB显存环境下可实现2000+ TPS,首token延迟<100ms,且具备官方NPU支持。备选方案Qwen 3.5旗舰版

FeelTouch Labs 766

数据结构与算法笔记:字典序最大问题分析

字典序最大问题 问题描述 给定一个1到n的排列(无序状态的),依次插入到栈中,在每时每刻都可以多次从栈中弹出栈顶 问:应如何使得弹出栈顶的序列的字典序最大,并输出这个序列 问题分析 什么是字典序 比如两个序列:5,4,3,2,1和1,2,3,4,5 这两个中第一个的字典序最大 每个位置上的数字比其他序列上同一位置的数字要大 比如:第一位置中5比1大,第二位置中4比2大这样 即:字典序最大 = 从左向右看这个序列,每个数字都尽量大 题目给定一个1到n的排列,每个数字只出现一次 要使出栈的字典序最大

Wang的专栏 4393

CANoe开发入门到精通读书笔记(2)——CAPL编程

CAPL函数的语法跟C语言很类似,但也包含一些C语言所不具备的功能大部分CAPL支持的数据类型都可以直接声明为函数参数, 例如,整型、浮点型、枚举、结构、定时器以及它们的引用。但有一些类型不能被直接声明,而需要加上*号(注意该符号并不是C语言中 指针的意思)。例 如 : signal * s 、 envvarInt * ev 、 sysvarFloat * sv 、 diagRequest * dr、diagResponse * dr、int matrix[][],以及。

weixin_66275497的博客 6462

x2-DFD:A framework for explainable and explainable deepfake detection

该文章提出了X2-DFD框架,用于可解释和可扩展的深度伪造检测。通过评估大型多模态语言模型(MLLMs)在深度伪造检测中的内在能力,发现它们在不同伪造相关特征上的有效性各异。基于此,实施了针对性的微调策略,显著提高了MLLMs的解释能力,并整合了外部深度伪造检测器(EDDs),以结合MLLMs和传统检测器的互补优势,实现更好的检测和解释。

志在山顶的人,不会贪念山腰的风景 511

数据结构与算法笔记:农夫过河问题python3实现

问题描述 农夫(Human)过河。一个农夫带着一只狼(Wolf),一只羊(Sheep)和一些菜(Vegetable)过河。河边只有一条船,由于船太小,只能装下农夫和他的一样东西。在无人看管的情况下,狼要吃羊,羊要吃菜,请问农夫如何才能使三样东西平安过河? 要求: 输出一行,为最终的过河方式,方案格式为 过河人员、回来人员、过河人员、回来人员、…、过河人员。 过去和回来的人员之间,用空格隔开。 以四...

Wang的专栏 3374

2026年寒武纪数字IC笔试试卷带答案

本文摘要: 该数字IC设计测试卷包含单选题(30分)、波形分析题(15分)、多选题(30分)三类客观题,覆盖时序约束、半导体工艺、状态机、数制转换、同步复位等核心知识点。重点考察:1)跨时钟域处理(如异步FIFO、格雷码应用);2)时序分析(建立/保持时间、时钟约束指令);3)低功耗设计技术(时钟门控、DVFS);4)寒武纪MLU架构特性(张量核、混合精度计算)。解析强调工程实践要点,如异步复位需同步释放、建立时间违例与频率的关联性等。试题难度梯度明显,既包含基础概念辨析(如Moore/Mealy状态机),

Open 224

数据结构与算法笔记:计算思维之经典农夫过河问题C++实现

农夫、羊、狼、菜的过河问题 问题描述 角色:农夫,羊,狼,菜 条件1:船很小,只能装下农夫和其他一个角色 条件2:无人看管,羊吃菜,狼吃羊 问:如何让其他三种角色被农夫平安带着过河? 相关分析 我们可以先用人脑尝试一下相关渡河策略 1 ) 先渡狼,人回来再渡菜,人回来再渡羊 2 ) 先渡菜,人回来再渡狼,人回来再渡羊 以上两种很好想到,而且我们可以知道羊这种角色是不能先渡河过去的,羊需要最后再渡 如果先渡了羊了,之后再渡任何其他角色,都要将羊带回来 可以参考小游戏:http://gameschool

Wang的专栏 3314

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

数据结构与算法笔记:图搜索之DFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的,比BSF要简单的多 同样,我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主,她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽,但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象

Wang的专栏 3119

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

数据结构与算法笔记:计算思维之人鬼渡河问题

人鬼渡河问题 1 ) 问题描述 目标:将东岸的3人3鬼通过一只小船安全转移到西岸,希望摆渡次数尽可能少 条件 船的容量有限,一次最多只能坐2人(或2鬼或1人1鬼) 无论是在河的东岸还是在河的西岸,一旦鬼数多于人数,则人将被鬼吃掉 怎样渡河的大权掌握在人的手中 说明:划船的时间忽略不计。船一靠岸即将船与岸视为一体,人和鬼即使还没有下 船也视为已上岸 任务:编写程序,求出一种渡河方案 备注:图片托管于github,请确保网络的可访问性 2 ) 分析 目标是找

Wang的专栏 2447

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

数据结构与算法之二叉树: LeetCode 701. 二叉搜索树中的插入操作 (Ts版)

1 ) 方案1:模拟。2 ) 方案2:递归。

Wang的专栏 2270

数据结构与算法笔记:计算思维之下楼梯台阶和象棋跳马问题

下台阶问题 1 ) 问题描述 从楼上走到楼下共有 h 个台阶,每一步有三种走法 走一个台阶; 走二个台阶; 走三个台阶。 问:一共可以走出多少种方案? 即共要多少步? 每一步走几级台阶? 2 ) 分析 初始思路 我们根据题目给定的场景,先简单模拟一下,设定 h=4h=4h=4 备注:图片托管于github,请确保网络的可访问性 如上图所示, 这里有4阶楼梯, 红色数字代表每一步走几级台阶 这里枚举了4层台阶的所有可能情况, 但是不管具体有几级台阶,下

Wang的专栏 2113

Python笔记:滑动验证码的识别算法

概述 用程序识别极验滑动验证码的验证,包括分析识别思路、识别缺口位置、生成滑块拖动路径、模拟实现滑块拼合通过验证等步骤。 准备工作 使用Python库是Selenium,浏览器为Chrome。请确保已安装Selenium库和ChromeDriver浏览器驱动。 关于极验滑动验证码: 极验滑动验证码官网为:http://www.geetest.com/ 验证方式为拖动滑块拼合图像,若图像完全拼合...

Wang的专栏 2104

数据结构与算法之堆: LeetCode 295. 数据流的中位数 (Ts版)

/ 返回 1.5 ((1 + 2) / 2)中位数是有序整数列表中的中间值。如果列表的大小是偶数,则没有中间值,中位数是两个中间值的平均值。3 ) 方案3:有序集合 + 双指针。2 ) 方案2:优先队列-优化版。1 ) 方案1:优先队列。

Wang的专栏 1907

数据结构与算法笔记:计算思维之谁做的好事与刑侦作案问题

谁做的好事 清华附中有四位同学中的一位做了好事,不留名,表扬信来了之后,校长问这四位是谁做的好事。 A说:不是我。 B说:是C。 C说:是D。 D说:他胡说。 已知:三个人说的是真话,一个人说的是假话。 现在请你根据这些信息,编写程序找出做了好事的人。 分析 将四个人说的四句话(自然语言)转换成计算机可以计算的式子, 可使用循环枚举的方式来判断 (1) 思路一:通过字符表示人 先定义一个字符变量 thisman 表示要寻找的做了好事的人的“名字(代号)”(A、B、C、D),即 char this

Wang的专栏 1833

数据结构与算法笔记:图搜索之BFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) 广度优先搜索BFS 我们可以用比喻来说明广度优先搜索算法 在一片草木枯黄的深秋草原上,在草原的某一处出现了一处野火 一开始的时候野火集中于一点之上,在这点野火耗尽当前植被变成灰烬之前点燃了周围的植被 比如节点s是初始火种,假设我们手中有一个秒表,每过1秒,我们的大火会向外迈进一步 这个过程只能向外,不能向内,因为只能点燃植被,不能把灰烬点燃 蓝色的点是即将变为灰烬的点,红色的点是刚被点燃的点,灰色的圆形或

Wang的专栏 1794

数据结构与算法之动态规划: LeetCode 1494. 并行课程 II (Ts版)

给你一个整数 n 表示某所大学里课程的数目,编号为 1 到 n ,数组 relations 中, relations[i] = [xi, yi] 表示一个先修课的关系,也就是课程 xi 必须在课程 yi 之前上。解释:上图展示了题目输入的图。一个最优方案是:第一学期上课程 2 和 3,第二学期上课程 4 ,第三学期上课程 1 ,第四学期上课程 5。然后第二个学期上课程 1 ,第三个学期上课程 4。在一个学期中,你 最多 可以同时上 k 门课,前提是这些课的先修课在之前的学期里已经上过了。

Wang的专栏 1749

数据结构与算法笔记:求直方图最大面积算法分析

直方图最大面积 问题描述 有n列的直方图,第j列高度为hjh_jhj​, 求一个面积最大的子矩阵 备注:图片托管于github,请确保网络的可访问性 格式要求 输入第一行正整数n,第二行n个空格隔开的非负整数 数据范围: 所有直方图的列不会超过30000 关键算法实现 1 ) 算法1:时间复杂度为: O(n3)O(n^3)O(n3)的实现 分析 矩形面积为底和高的乘积 底部从a到b,那么底边长为: b-a+1 高为:min{hi∣a≤i≤b}min \{h

Wang的专栏 1664

数据结构与算法之LRU: 实现 LRU 缓存算法功能 (Ts, Py, Go版)

LRU - Lease Recently Used 最近使用如果内存优先,只缓存最近使用的,删除 ‘沉睡’ 数据核心 api: get set分析。

Wang的专栏 1599

数据结构与算法之贪心: LeetCode 455. 分饼干 (Ts, Py, Go版)

对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j]。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。2 )排序 + 双指针 + 贪心。1 )排序 + 遍历。

Wang的专栏 1568
上一篇: 数据结构与算法之排序: 基数排序 (Ts, Py, Go版)
下一篇: 数据结构与算法之查找: 顺序查找 (Ts, Py, Go版)
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值