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

【信息科学与工程学】计算机科学与技术——第七十七篇 系统架构设计02 编号类型模型配方企业资本运作的方法/规则/条件/依据及所有的步骤(​风险处理/异常处理/危机应对关联知识法律法规和裁决依据​​由发起人(通常是知名投资人、投行或产业资本)先设立一个只有现金、无实际业务的特殊目的收购公司(SPAC),通过IPO募集资金并在交易所上市。然后在规定时间内(通常24个月)寻找一家非上市公司进行合并(De-SPAC),使目标公司迅速实现上市,规避传统IPO的复杂流程和不确定性。1.:在开曼或特拉华注册空壳公司,注入少量种子资金。2. 阅读详情

排序

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

基数排序

  • 核心思想
    • 按照位数来进行分层,“个”, “十”, “百”, “千”, …
      • 得到数组中的最低位和最高位
      • 准备一个合适的数组 m (下标0-9对应当前位数的值)
    • 按照最低位优先的策略开始将当前位数上的值存入m对应下标的元素中(这个元素是数组或是链表, 但是一般而言我们处理的时候,使用计数排序中的累计数组来处理)
    • 将按照下标存储的当前位数的所有数据按下标顺序拍平处理,当前位数存储完毕,这时候只看当前位数是有序的
    • 得到新数组开始向下一级高位的处理,按照这个流程直到所有位数处理完毕,整个数组就有序了
  • 简单来说
    • 0-9准备10个桶
    • 将原数组元素先按照个位对应分配到桶里并收集 (数位较短的前面补0)
      • 在这个过程中,需要来回折腾数据
      • 处理过程如下代码所示
    • 再处理十位,百位,直到全部位数分配完成,收集后的数组就是最终有序的数组
  • 基数排序是桶排序的一种扩展

Typescript 版算法实现


1 ) 方案1

function radixSort(list: number[]) {
	const len: number = list.length; // 获取数组长度
	const max: number = Math.max(...list); // 获取数组中最大值
	let i: number = 0; // 用于计数的数组
	let radix: number = 1; // 基数(个:1, 十:10, 百: 100, ...)
	const tmp: number[] = new Array(len); // 临时倒腾数组
    let currentRadixNum: number;
	// while(max / radix > 0) { // 备注,这样在LeetCode里效率会下降
	while(max >= radix) {
		// 初始化存储桶 0 ~ 9, 全0填充
		const bucket = new Array(10).fill(0);
		// 对当前基数下的值进行累加计算总数
		for(i = 0; i < len; i ++) {
			// 获取当前基数下的值, 也就是对应的桶的下标
			currentRadixNum = Math.floor(list[i] / radix) % 10;
			bucket[currentRadixNum] ++; // 从 0 开始自增, 这里桶中存储的是当前下标下对应数据的累计个数
		}
		// 计算当前数据位置: 基于桶内每个下标对应数据的累计个数,计算当前元素在整个桶中的位置,并反向赋值给当前桶
		for(i = 1; i < 10; i ++) {
			bucket[i] += bucket[i-1];
		}
		// 将a[i]的值按照桶存储的位置倒腾到临时数组tmp中
		for(i = len - 1; i >= 0; i --) {
			currentRadixNum = Math.floor(list[i] / radix) % 10; // 当前基数下的数字
			const currentIndex = bucket[currentRadixNum] - 1; // bucket存储的是位置,位置-1为下标
			tmp[currentIndex] = list[i]; // 根据桶存储的位置, 
			bucket[currentRadixNum] --; // 桶内当前元素累计值 自减
		}
		// 再将临时数组中的元素倒腾回list中,此时完成了一轮的基于基数的处理
		list.splice(0, len, ...tmp);
		radix *= 10; // 基数进位处理
	}
}

const list: number[] = [100, 34, 1002, 1234, 66, 137, 49, 102, 9, 108, 102, 101, 104, 109, 102];
radixSort(list);
console.log(list); // [9, 34, 49, 66, 100, 101, 102, 102, 102, 104, 108, 109, 137, 1002, 1234]

优化 支持负数

function radixSort(list: number[]): number[] {
    const len: number = list.length;
    if (len < 2) return list;

    // 找到最大值和最小值
    const max: number = Math.max(...list);
    const min: number = Math.min(...list);

    // 如果有负数,将所有数转换为非负数
    const offset: number = min < 0 ? -min : 0;
    const adjustedList: number[] = list.map(num => num + offset);

    // 基数排序
    let radix: number = 1;
    const maxAdjusted: number = max + offset;
    const tmp: number[] = new Array(len);
    while (maxAdjusted >= radix) {
        // 初始化存储桶 0 ~ 9, 全0填充
        const bucket: number[] = new Array(10).fill(0);
        // 对当前基数下的值进行累加计算总数
        for (let i = 0; i < len; i++) {
            const currentRadixNum: number = Math.floor(adjustedList[i] / radix) % 10;
            bucket[currentRadixNum]++;
        }
        // 计算当前数据位置: 基于桶内每个下标对应数据的累计个数,计算当前元素在整个桶中的位置,并反向赋值给当前桶
        for (let i = 1; i < 10; i++) {
            bucket[i] += bucket[i - 1];
        }
        // 将a[i]的值按照桶存储的位置倒腾到临时数组tmp中
        for (let i = len - 1; i >= 0; i--) {
            const currentRadixNum: number = Math.floor(adjustedList[i] / radix) % 10;
            const currentIndex: number = bucket[currentRadixNum] - 1;
            tmp[currentIndex] = adjustedList[i];
            bucket[currentRadixNum]--;
        }
        // 再将临时数组中的元素倒腾回list中,此时完成了一轮的基于基数的处理
        adjustedList.splice(0, len, ...tmp);
        radix *= 10;
    }

    // 将所有数转换回原来的值
    return adjustedList.map(num => num - offset);
}

function testRadixSort() {
    const testCases: number[][] = [
        [100, 34, 1002, 1234, 66, 137, 49, 102, 9, 108, 102, 101, 104, 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 (const testCase of testCases) {
        const copyList: number[] = [...testCase];
        const sortedList: number[] = radixSort(copyList);
        console.log(`Original: ${testCase}, Sorted: ${sortedList}`);
    }
}

testRadixSort();

Python3 版算法实现


1 ) 方案1: 支持负数


def radix_sort(arr):
    if len(arr) < 2:
        return arr
    
    # 找到最大值和最小值
    max_val = max(arr)
    min_val = min(arr)
    
    # 如果有负数,将所有数转换为非负数
    offset = -min_val if min_val < 0 else 0
    adjusted_arr = [num + offset for num in arr]
    
    # 基数排序
    max_val_adjusted = max(adjusted_arr)
    radix = 1
    tmp = [0] * len(arr)
    while max_val_adjusted >= radix:
        bucket = [0] * 10
        for num in adjusted_arr:
            current_radix_num = (num // radix) % 10
            bucket[current_radix_num] += 1
        for i in range(1, 10):
            bucket[i] += bucket[i - 1]
        for i in range(len(adjusted_arr) - 1, -1, -1):
            current_radix_num = (adjusted_arr[i] // radix) % 10
            current_index = bucket[current_radix_num] - 1
            tmp[current_index] = adjusted_arr[i]
            bucket[current_radix_num] -= 1
        adjusted_arr[:] = tmp[:]
        radix *= 10
    
    # 将所有数转换回原来的值
    arr[:] = [num - offset for num in adjusted_arr]
    return arr

def test_radix_sort():
    test_cases = [
        [100, 34, 1002, 1234, 66, 137, 49, 102, 9, 108, 102, 101, 104, 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 = radix_sort(copy_list)
        print(f"Original: {test_case}, Sorted: {sorted_list}")

if __name__ == "__main__":
    test_radix_sort()

Golang 版算法实现


1 ) 方案1: 支持负数

package main

import (
	"fmt"
)

func radixSort(arr []int) {
	length := len(arr)
	if length < 2 {
		return
	}

	// 找到最大值和最小值
	maxVal, minVal := arr[0], arr[0]
	for _, num := range arr {
		if num > maxVal {
			maxVal = num
		}
		if num < minVal {
			minVal = num
		}
	}

	// 如果有负数,将所有数转换为非负数
	offset := -minVal
	if minVal >= 0 {
		offset = 0
	}
	adjustedArr := make([]int, length)
	for i, num := range arr {
		adjustedArr[i] = num + offset
	}

	// 基数排序
	maxValAdjusted := maxVal + offset
	radix := 1
	tmp := make([]int, length)
	for maxValAdjusted >= radix {
		bucket := make([]int, 10)
		for _, num := range adjustedArr {
			currentRadixNum := (num / radix) % 10
			bucket[currentRadixNum]++
		}
		for i := 1; i < 10; i++ {
			bucket[i] += bucket[i-1]
		}
		for i := length - 1; i >= 0; i-- {
			currentRadixNum := (adjustedArr[i] / radix) % 10
			currentIndex := bucket[currentRadixNum] - 1
			tmp[currentIndex] = adjustedArr[i]
			bucket[currentRadixNum]--
		}
		copy(adjustedArr, tmp)
		radix *= 10
	}

	// 将所有数转换回原来的值
	for i, num := range adjustedArr {
		arr[i] = num - offset
	}
}

func testRadixSort() {
	testCases := [][]int{
		{100, 34, 1002, 1234, 66, 137, 49, 102, 9, 108, 102, 101, 104, 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)
		radixSort(copyList)
		fmt.Printf("Original: %v, Sorted: %v\n", testCase, copyList)
	}
}

func main() {
	testRadixSort()
}

总结

  • 基数排序时间复杂度 O(kn) ≈ O(n) k是常数
    • 最外层的 max/base 是常数级别, 内部的多个for循环也是常数,即: 常数 k
  • 基数排序也可理解为按关键字(这里的关键字就是基数radix)排序
  • 非比较排序,基于下标的顺序来回赋值, 使用计数排序的思想做累加数组
  • 基数排序基于计数排序,是桶排序的一种, 又称多关键字排序
  • 最好从个位(低位)先开始排起,这是一种比较简单的处理方式
    • 高位优先需要用到递归,就复杂一些
  • 是一种思想简单,实现起来有些复杂的算法
  • 因其基于计数排序,所以基数排序的适用场景也是基数排序需要考虑的场景
STM32F103C8T6与OV7670摄像头在TFT屏上的实时数字识别系统实现 本文详细介绍了基于STM32F103C8T6单片机和OV7670摄像头实现实时数字识别系统的全过程。系统通过图像采集、预处理、二值化和模板匹配算法,在TFT屏上实时显示识别结果,并针对资源受限的单片机环境提供了内存与性能优化策略,适用于智能家居、工业仪表读数等低成本嵌入式视觉应用场景。 阅读详情

相关推荐

解决西门子Step 7 basic 找不到许可证问题

你在使用博图软件是否遇到过Step 7 basic 找不到许可证的问题呢!不言怕,今天我就来告诉你该如何处理吧!看步骤: 1.删除原授权的License: 打开Automation License Manager应用,然后我们可以发现仅有的License Key前面有一个时钟,说明它已经过期不可用,我们就要去寻求新的Key. 打开“我的电脑”,选择C盘,点击上方查看 点击选项–>查看 然...

让技术没有门槛 14万+

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

桶排序的时间复杂度 在 O(n) ~ O(n2n^2n2普通桶排序并不普遍应用是拆分为桶后,在每个桶内还需要排序,意义就不大了而且要考虑每个桶内用什么样的数据结构来存储(考虑到内部排序)如果还用数组就极大浪费了空间(需使用最大的空间, 不同语言有区别)一般可以使用链表,但是对链表排序又开始麻烦了桶排序优化空间,时间上就会增加;优化时间空间上又会增多, 取一个时间和空间的平衡。

Wang的专栏 416

工业数据采集实战:用open62541库读写PLC的OPC UA节点(避坑指南)

本文详细介绍了如何使用open62541库实现工业PLC的OPC UA节点数据采集,涵盖环境搭建、节点读写优化及生产环境故障排查。通过订阅模式和多节点读写技术,显著提升数据采集效率与稳定性,适用于智能制造和工业物联网场景。

weixin_30598225的博客 401

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

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

Wang的专栏 402

统信UOS/麒麟ARM桌面版,不联网也能用Docker部署MySQL 5.7(离线部署详解)

本文详细介绍了在统信UOS/银河麒麟ARM桌面版系统中,如何离线部署MySQL 5.7的完整流程。通过Docker技术实现环境隔离和依赖封装,解决了封闭网络环境下的部署难题,包括资源准备、系统配置、容器化部署及安全加固等关键步骤,为政企和科研场景提供实用解决方案。

weixin_30892037的博客 230

Wireshark抓包实战:5个CTF比赛中高频出现的流量分析技巧(附真实案例)

本文分享了Wireshark在CTF比赛和实战渗透中的五个核心流量分析技巧。内容涵盖从宏观统计概览锁定可疑目标、深度解析ICMP与HTTP等协议、追踪重组完整会话流,到利用字符串搜索和命令行工具进行自动化分析。掌握这些高阶技巧能显著提升分析海量网络流量的效率与精准度。

rrr55的博客 262

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

计数排序的适用范围有限:最优版时间复杂度可降低到 O(n), 是最快的排序算法, 但是有两个前提需要满足1)需要排序的元素必须是非负整数(下标不能是负数和小数 2)排序元素的取值要在一定范围内,并且比较集中满足以上两个条件,才能最大发挥出计数排序的优势, 否则不适用计数排序的缺点基础版空间浪费,优化版解决了这个问题将数组长度定为 max-min+1, 即不仅要找出最大值,还要找出最小值缺点弥补:根据两者的差来确定计数数组的长度则可弥补之计数排序是非常稳定的排序算法,但是适用场景确实有限。

Wang的专栏 429

基于物联网技术智慧园林绿化养护管理信息平台

近几年来,随着经济不断的发展,城市面积不断的扩大,城市管理中的园林绿化工作也在这种趋势下不断的发生着深刻改变。管养企业是否按制定的管养计划严格执行?绿化事件整改是否及时到位?绿地面积是否在稳步增长?管养的效果如何?如何客观评价管养企业的管养工作?这些都是我们各级管理者需要面对的问题。   智慧园林绿化养护管理信息平台的开发思路以“考核”为核心,整个信息平台体现出“新、快、高、全、享”五个特点。   智慧园林绿化养护管理信息平台的整个开发理念为:依托五大技术手段(全球卫星定位系统技术、地理信...

Cesium的博客QQ2252224326 2460

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

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

Wang的专栏 4393

SOC估算方法之(OCV-SOC+安时积分法)

此方法主要参考。

m0_61973119的博客 939

A100 NVLink集群极致优化指南

《A100 NVLink集群通信优化指南》摘要:针对A100 80G SXM机型NVLink 3.0集群,提供硬件配置检查方法(nvidia-smi topo -m)和强制启用指令。重点介绍NCCL参数调优(算法选择、低延迟协议配置)、GPUDirect RDMA启用步骤,以及单机/多机场景下的通信模式选择。包含PyTorch all_reduce基准测试方法,并给出带宽异常排查方案(dmesg检查、NCCL缓存重置)。通过CUDA Graph通信重叠和混合精度优化,可实现90%+带宽利用率。附猿界算力监控

2401_89353317的博客 592

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

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

Wang的专栏 3374

〔重庆理工大学〕大学物理实验--变温霍耳效应及其参数测定

每个老师要求不同,实验报告内容和数据仅供参考。

Pretty Boy Fox的博客 3044

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

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

Wang的专栏 3314

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

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

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

Wang的专栏 3119

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

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

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

Wang的专栏 2447

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

数据结构与算法之二叉树: 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、付费专栏及课程。

余额充值