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

LLM编程效率真相:Token消耗量才是核心指标 在大模型辅助编程(LLM-assisted programming)实践中,开发者常误将代码生成速度或语法简洁性等同于效率,实则真实成本藏于人机交互过程——即token消耗量。其本质是模型对语言抽象范式(如并发模型、数据结构、协议表达)的理解匹配度,直接决定输入上下文复杂度、调试轮次与首次通过率(first-pass correctness)。高token开销往往源于LLM对锁机制、channel语义或JSON序列化等概念的偏差,而非语言本身。该指标深刻关联API计费、本地推理延迟与工程迭代节奏,已成为评估 阅读详情

排序

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

计数排序

  • 核心思想:通过计数而非比较来进行排序,借助数组下标本身就是有序的原理实现
  • 适用范围:较小的非负整数序列和最小值和最大值之间的数字范围比较合适
  • 基数排序需要新增一个计数数组(待累计数组)
    • 计数数组:即新的临时的初始化数组用于计数,需要找到原始数组中最大的值,再加1,才是这个数组的长度,存储 [0 ~ max]
    • 累计数组:是由计数数组计算后得到的,下标是原数组的值,元素值是累计的个数,即重复的个数

Typescript 版算法实现


1 )基础版本

function countSort(list: number[]) {
	const len: number = list.length;
	if (len < 2) return;
	// 获取最大值
	// const max = Math.max.apply(null, list);
	const max: number = Math.max(...list);
	// 初始化计数数组
	const countList: number[] = new Array(max + 1).fill(0); // 数组大小,存放[0~max]
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	let i: number;
	for(i = 0; i < len; i++) countList[list[i]]++; // 遍历完成后计数数组就变成了累计数组
	// 基于累计数组生成排好序的数组,这里利用了下标即是有序的原理
	i = 0; // 重新使用i
	for(let j: number = 0; j < max + 1; j++) {
    	// 内层循环不会到n, 一般是常数级别的,但是这样写似乎也不是太好,嵌套会增加时间复杂度
		for (let k: number = 0; k < countList[j]; k++) list[i++] = j; // 这里j就是下标,其实就是原数组的值
	}
}

const list = [2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2];
countSort(list);
console.log(list); // [1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]

2 )优化版本:优化时间复杂度(空间换时间)

function countSort(list: number[]): number[] {
	const len: number = list.length;
	if (len < 2) return list;
	// 获取最大值和最小值
	// const max = Math.max.apply(null, list);
	// const min = Math.min.apply(null, list);
	const max: number = Math.max(...list);
	const min: number = Math.min(...list);
	// 初始化计数数组
	const countList: number[] = new Array(max - min + 1).fill(0);
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for(let i: number = 0; i < len; i++) countList[list[i] - min]++; // 遍历完成后计数数组就变成了累计数组
	// 基于累计数组生成排好序的数组,这里利用了下标即是有序的原理
	let result: number[] = [];
	for(let j: number = 0; j < max + 1; j++) {
		if (!countList[j]) continue;
		countList[j] > 1 ? (result = result.concat(new Array(countList[j]).fill(j + min))) : result.push(j + min);
	}
	return result; // 替换
}

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

3 )优化版本:优化时间复杂度(空间换时间) + 优化存储空间

function countSort(list: number[]) {
	const len: number = list.length;
	if (len < 2) return list;
	// 获取最大值和最小值
	const max: number = Math.max(...list);
	const min: number = Math.min(...list);
	// 初始化计数数组
	const countList: number[] = new Array(max - min + 1).fill(0);
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for(let i: number = 0; i < len; i++) countList[list[i] - min]++; // 遍历完成后计数数组就变成了累计数组
	// 基于累计数组生成排好序的数组,这里利用了下标即是有序的原理
	let str: string = ''; // 用字符串来处理
	for(let j: number = 0; j < max - min + 1; j++) {
		if (!countList[j]) continue;
		str += countList[j] > 1 ? ((j + min) + ',').repeat(countList[j]) : (j + min) + ',';
	}
	str = str.substring(0, str.length - 1); // 最后一个 , 是多余的
	return str.split(',').map(item => Number(item));
}

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

4 )优化版本:优化时间复杂度(累计数组变位置数组,基于差值和位置来对应顺序)

function countSort(list: number[]) {
	const len: number = list.length;
	if (len < 2) return;
	// 获取最大值和最小值
	const max: number = Math.max(...list);
	const min: number = Math.min(...list);
	// 初始化计数数组
	const countList: number[] = new Array(max - min + 1).fill(0);
	// 初始化目标数组
	const result: number[] = new Array(len);
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for(let i: number = 0; i < len; i++) countList[list[i] - min]++; // 遍历完成后计数数组就变成了累计数组
	// 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
	for(let j: number = 1; j < max - min + 1; j++) {
		countList[j] += countList[j - 1];
	}
	// 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组,备注:数据可能重复,使用过的数据记得-1,从后向前遍历更好理解
	for (let k: number = len - 1; k >= 0; k--) {
		const currentIndex = countList[list[k] - min] - 1;
		result[currentIndex] = list[k]; // 将原数组的当前元素整合到 result数组对应的位置之中
		countList[list[k] - min] --; // 使用一次后,累计的数量自减,防止重复使用导致错误
	}
	list.splice(0, len, ...result); // 优化下方式,不用return, 直接替换
}

const list: number[] = [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102];
countSort(list);
console.log(list); // [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]

Python3 版算法实现


1 ) 方案1

def count_sort(list):
    length = len(list)
    if length < 2:
        return
    # 获取最大值
    max_val = max(list)
    # 初始化计数数组
    count_list = [0] * (max_val + 1)
    # 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
    for num in list:
        count_list[num] += 1
    # 基于累计数组生成排好序的数组
    i = 0
    for j in range(max_val + 1):
        for _ in range(count_list[j]):
            list[i] = j
            i += 1

list = [2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
count_sort(list)
print(list)  # 输出: [1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]

2 ) 方案2

def count_sort(list):
    length = len(list)
    if length < 2:
        return list
    # 获取最大值和最小值
    max_val = max(list)
    min_val = min(list)
    # 初始化计数数组
    count_list = [0] * (max_val - min_val + 1)
    # 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
    for num in list:
        count_list[num - min_val] += 1
    # 基于累计数组生成排好序的数组
    result = []
    for j in range(max_val - min_val + 1):
        if count_list[j] == 0:
            continue
        if count_list[j] > 1:
            result.extend([j + min_val] * count_list[j])
        else:
            result.append(j + min_val)
    return result

list = [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102]
result = count_sort(list)
print(result)  # 输出: [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]

3 ) 方案3

def count_sort(list):
    length = len(list)
    if length < 2:
        return list
    # 获取最大值和最小值
    max_val = max(list)
    min_val = min(list)
    # 初始化计数数组
    count_list = [0] * (max_val - min_val + 1)
    # 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
    for num in list:
        count_list[num - min_val] += 1
    # 基于累计数组生成排好序的数组
    str_result = ''
    for j in range(max_val - min_val + 1):
        if count_list[j] == 0:
            continue
        if count_list[j] > 1:
            str_result += ((str(j + min_val) + ',') * count_list[j])
        else:
            str_result += str(j + min_val) + ','
    str_result = str_result.rstrip(',')
    # 转换为整数数组
    result = [int(item) for item in str_result.split(',')]
    return result

list = [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102]
result = count_sort(list)
print(result)  # 输出: [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]

4 ) 方案4

def count_sort(list):
    length = len(list)
    if length < 2:
        return
    # 获取最大值和最小值
    max_val = max(list)
    min_val = min(list)
    # 初始化计数数组
    count_list = [0] * (max_val - min_val + 1)
    # 初始化目标数组
    result = [0] * length
    # 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
    for num in list:
        count_list[num - min_val] += 1
    # 计算位置: 由上面的累计结果,计算累加后的位置
    for j in range(1, len(count_list)):
        count_list[j] += count_list[j - 1]
    # 根据累加后的位置, 将原数组中的数据按照位置进行分配
    for k in range(length - 1, -1, -1):
        current_index = count_list[list[k] - min_val] - 1
        result[current_index] = list[k]
        count_list[list[k] - min_val] -= 1
    # 替换原数组
    list[:] = result

list = [102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102]
count_sort(list)
print(list)  # 输出: [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]

Golang 版算法实现


1 ) 方案1

package main

import (
	"fmt"
)

func countSort(list []int) {
	length := len(list)
	if length < 2 {
		return
	}
	// 获取最大值
	max := list[0]
	for _, num := range list {
		if num > max {
			max = num
		}
	}
	// 初始化计数数组
	countList := make([]int, max+1)
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for i := 0; i < length; i++ {
		countList[list[i]]++
	}
	// 基于累计数组生成排好序的数组
	i := 0
	for j := 0; j < max+1; j++ {
		for k := 0; k < countList[j]; k++ {
			list[i] = j
			i++
		}
	}
}

func main() {
	list := []int{2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2}
	countSort(list)
	fmt.Println(list) // 输出: [1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]
}

2 ) 方案2

package main

import (
	"fmt"
)

func countSort(list []int) []int {
	length := len(list)
	if length < 2 {
		return list
	}
	// 获取最大值和最小值
	max, min := list[0], list[0]
	for _, num := range list {
		if num > max {
			max = num
		}
		if num < min {
			min = num
		}
	}
	// 初始化计数数组
	countList := make([]int, max-min+1)
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for i := 0; i < length; i++ {
		countList[list[i]-min]++
	}
	// 基于累计数组生成排好序的数组
	result := make([]int, 0, length)
	for j := 0; j < max-min+1; j++ {
		if countList[j] == 0 {
			continue
		}
		if countList[j] > 1 {
			result = append(result, make([]int, countList[j])...)
			for k := 0; k < countList[j]; k++ {
				result[len(result)-k-1] = j + min
			}
		} else {
			result = append(result, j+min)
		}
	}
	return result
}

func main() {
	list := []int{102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102}
	result := countSort(list)
	fmt.Println(result) // 输出: [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]
}

3 ) 方案3

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func countSort(list []int) []int {
	length := len(list)
	if length < 2 {
		return list
	}
	// 获取最大值和最小值
	maxVal, minVal := list[0], list[0]
	for _, num := range list {
		if num > maxVal {
			maxVal = num
		}
		if num < minVal {
			minVal = num
		}
	}
	// 初始化计数数组
	countList := make([]int, maxVal-minVal+1)
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for _, num := range list {
		countList[num-minVal]++
	}
	// 基于累计数组生成排好序的数组,这里利用了下标即是有序的原理
	var strBuilder strings.Builder
	for j := 0; j < maxVal-minVal+1; j++ {
		if countList[j] == 0 {
			continue
		}
		if countList[j] > 1 {
			strBuilder.WriteString(strings.Repeat(fmt.Sprintf("%d,", j+minVal), countList[j]))
		} else {
			strBuilder.WriteString(fmt.Sprintf("%d,", j+minVal))
		}
	}
	str := strBuilder.String()
	str = strings.TrimSuffix(str, ",") // 去掉最后一个逗号
	// 转换为整数数组
	result := make([]int, 0, length)
	for _, s := range strings.Split(str, ",") {
		num, _ := strconv.Atoi(s)
		result = append(result, num)
	}
	return result
}

func testCountSort() {
	testCases := [][]int{
		{2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2}, // 一般情况
		{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)
		result := countSort(copyList)
		fmt.Printf("Original: %v, Sorted: %v\n", testCase, result)
	}
}

func main() {
	testCountSort()
}

4 ) 方案4

package main

import (
	"fmt"
)

func countSort(list []int) {
	length := len(list)
	if length < 2 {
		return
	}
	// 获取最大值和最小值
	max, min := list[0], list[0]
	for _, num := range list {
		if num > max {
			max = num
		}
		if num < min {
			min = num
		}
	}
	// 初始化计数数组
	countList := make([]int, max-min+1)
	// 初始化目标数组
	result := make([]int, length)
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for i := 0; i < length; i++ {
		countList[list[i]-min]++
	}
	// 计算位置: 由上面的累计结果,计算累加后的位置
	for j := 1; j < len(countList); j++ {
		countList[j] += countList[j-1]
	}
	// 根据累加后的位置, 将原数组中的数据按照位置进行分配
	for k := length - 1; k >= 0; k-- {
		currentIndex := countList[list[k]-min] - 1
		result[currentIndex] = list[k]
		countList[list[k]-min]--
	}
	// 替换原数组
	copy(list, result)
}

func main() {
	list := []int{102, 103, 108, 107, 101, 102, 102, 102, 107, 103, 109, 108, 102, 101, 104, 102, 104, 106, 109, 102}
	countSort(list)
	fmt.Println(list) // 输出: [101, 101, 102, 102, 102, 102, 102, 102, 102, 103, 103, 104, 104, 106, 107, 107, 108, 108, 109, 109]
}

总结

  • 计数排序的适用范围有限:最优版时间复杂度可降低到 O(n), 是最快的排序算法, 但是有两个前提需要满足
    • 1)需要排序的元素必须是非负整数(下标不能是负数和小数)
      • 如果是小数,需要将全部元素同等扩大到整数,之后再回归到小数
      • 一般不考虑这种小数场景
    • 2)排序元素的取值要在一定范围内,并且比较集中(量大,范围小)
  • 满足以上两个条件,才能最大发挥出计数排序的优势, 否则不适用
  • 计数排序的缺点
    • 基础版空间浪费,优化版解决了这个问题
    • 将数组长度定为 max-min+1, 即不仅要找出最大值,还要找出最小值
  • 缺点弥补:根据两者的差来确定计数数组的长度则可弥补之
  • 计数排序是非常稳定的排序算法,但是适用场景确实有限
  • 计数排序是一种桶排序的思想
二分查找原理与Python工程实践:从算法逻辑到bisect模块深度应用 二分查找是一种在有序数据结构中实现O(log n)时间复杂度的高效搜索算法,其核心依赖数据的单调性与随机访问能力。它并非简单‘找值’工具,而是支撑高性能系统的关键基础能力——通过每次比较排除一半候选空间,实现对百万级乃至十亿级数据的亚毫秒响应。在Python中,该能力既可通过手写while循环精准控制边界逻辑,也可借助标准库bisect模块获得C级性能,或结合NumPy进行向量化加速。实际工程中,需特别关注排序语义一致性、浮点精度归一化、自定义对象比较协议及Unicode排序规则等现实约束。本文聚焦sort 阅读详情

相关推荐

一人公司算法部署实战:Docker+uWSGI+Nginx极简生产链路

算法模型部署本质是将离线推理能力转化为稳定、可观测、可运维的在线服务。其核心原理在于环境隔离、进程管控与流量调度三层协同:Docker解决依赖冲突与跨平台一致性,uWSGI实现GPU显存管理与请求级生命周期控制,Nginx承担SSL终止、连接复用与熔断限流。这一技术组合虽非前沿,却是零运维资源下保障服务可用性(99.5%+)、低延迟(<500ms)与弹性伸缩的关键路径。广泛适用于工业质检、智能安防、边缘AI等需快速交付算法API的一人团队场景,尤其契合PyTorch/TensorFlow模型在单台4核8G云

weixin_30598225的博客 607

常见排序 ts实现

常见排序ts实现

little_boyyy的博客 836

MySort.ts TS通用排序方法

/** * 通用排序方法 * @param arr 需要排序的数组 * @param field 排序字段 值类型传null 单字段传string 多字段传数组[["field1", SortType], ["field2", SortType]] 可传属性名 方法名 * @param sortType 排序类型 SortType枚举 * @returns * 值排序示例:Utils.mySort(sortArr, null, SortType.Down); * 单字段排序示例:Utils.mySort(sortArr, "getItemQuality", SortType.OrderDown); * 多字段排序示例:Utils.mySort(stoneArr, [["getItemQuality", SortType.OrderUp], ["getItemNum", SortType.OrderUp]]); */ public static mySort(arr: any[], field?: any, sortType = SortType.OrderUp): void 支持各种类型的排序,可以免去自己写compare方法

常用排序算法(TS版)

文章目录0 算法概述0.1 算法分类0.2 相关概念0.3 算法复杂度1 冒泡排序 ( Bubble Sort )1.1 算法描述1.2 代码实现1.3 算法分析2 选择排序 ( Selection Sort )2.1 算法描述2.2 代码实现2.3 算法分析3 插入排序 ( Insertion Sort )3.1 算法描述3.2 代码实现3.3 算法分析4 希尔排序 ( Shell Sort ...

氽氽的博客 1633

桑基图实战指南:Excel/Python/R三工具高效绘制方法

桑基图是一种以线条宽度编码流量大小、以节点位置表达流程阶段、以连接关系呈现数据流向的专项可视化技术,其核心原理在于‘宽即量、位即序、连即逻辑’。它并非装饰性图表,而是面向业务诊断的分析前置工具,尤其适用于预算分配、能源损耗、用户转化等存在明确单向流动与显著数值差异的场景。相比传统柱状图或漏斗图,桑基图能天然暴露系统瓶颈与隐性损耗,大幅提升决策效率。本文聚焦工程落地,覆盖Excel插件快速交付、Python Plotly交互开发、R networkD3生态集成三大主流路径,兼顾数据准备铁律、索引映射规范与中文

cuml0912的博客 489

华为硬件工程师笔试题

1、基尔霍夫定理的内容是什么?(仕兰微电子)   基尔霍夫定理包括电流定律和电压定律。   电流定律(KCL):在集总电路中,任何时刻,对任一结点,所有流出结点的支路电流的代数和恒等于零。   电压定律(KVL):在集总电路中,任何时刻,沿任一回路,所有支路电压的代数和恒等于零。   2、平板电容公式(C=εS/4πkd)。(未知)   3、最基本的如三极管曲线特性。(未知)   4、描述反馈电路...

weixin_33717117的博客 2万+

TypeScript实现数组相关简单算法

算法(algorithm),在数学(算学)和计算机科学之中,为任何良定义的具体计算步骤的一个序列,常用于计算、数据处理和自动推理。精确而言,算法是一个表示为有限长列表的有效方法。算法应包含清晰定义的指令用于计算函数。 - 来自维基百科 写在前面 ...

weixin_34259159的博客 424

五子棋ai:极大极小搜索和α-β剪枝算法的思想和实现(qt和c++)(一)引言和界面设计

引言 alphaGo击败围棋冠军李世石的新闻让我对棋类博弈产生了浓厚的兴趣,无奈本人不会围棋,但算是一个五子棋业余爱好者,于是乎希望通过实现一个五子棋ai来了解相关算法和知识。 五子棋在英文中又称Gobang,five-in-row,还有两个称呼:gomoku和renju(连珠)。我来简要介绍一下区别。由于五子棋已经被机器严格证明了是一种**“不公平”的游戏,先手黑子是绝对占优的,并且先手有必胜*...

livingsu的博客 1万+

TypeScript(中)+算法(二)

从语法上讲:函数是可以返回 undefined 的,⾄于显式返回,还是隐式返回,这⽆所谓从语义上讲:函数调⽤者不应关⼼函数返回的值,也不应依赖返回值进⾏任何操作!即使我们知道它返回了 undefined。

2302_80277784的博客 1159

从Power到HO:一文搞懂主流脑图谱在DPABI里怎么选,让你的rs-fMRI分析更精准

本文深入解析了rs-fMRI分析中主流脑图谱(如Power、HO、AAL等)在DPABI中的科学选择策略,帮助研究者根据不同的神经科学研究目标优化分析流程。从解剖学图谱到功能连接图谱的特性对比,到DPABI实操中的多图谱分析工作流,提供了全面的方法论指导,助力提升静息态功能磁共振成像(rs-fMRI)研究的精准度和可重复性。

weixin_30654583的博客 405

基于深度学习的垃圾邮件识别

垃圾邮件的大量存在严重威胁着电子邮件系统的安全和效率。基于深度学习的垃圾邮件识别技术已经成为目前最有效的解决方案之一。本文将详细介绍使用深度学习技术进行垃圾邮件识别的方法,并提供相应的代码实现。 随着电子邮件的广泛应用,垃圾邮件的数量不断增加,传统的规则和统计方法已经无法满足对垃圾邮件进行准确识别的需求。深度学习技术以其强大的模式识别能力和自动特征提取能力成为解决垃圾邮件识别难题的有效工具。

一键难忘的博客 1095

TS实现排序算法之选择排序

TS实现排序算法之选择排序

Hi-Sun的博客 444

把 SAP Fiori Launchpad Designer 的 Catalog 与 Group 传输讲透:从 CONF、CUST 到 Transport Request 的完整理解

SAP Fiori项目中,catalog和group的传输问题往往源于对FLPD层次模型的理解不足。FLPD包含configuration(系统级)和customizing(客户端级)两个层面,分别对应workbench request和customizing request传输方式。常见误区包括:混淆/UI2/FLPD_CONF和/UI2/FLPD_CUST入口、未提前创建传输请求、不了解层次覆盖机制(customizing会覆盖configuration)。当客户端修改configuration层的对象

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 102

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

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

Wang的专栏 416

MATLAB基础应用精讲-【数模应用】PPO算法(附python代码实现)(二)

表示为状态转移概率和动作选择概率的乘积,因为状态和动作决定轨迹。

qq_36130719的博客 414

Spring AI Alibaba 项目源码学习(九)-其他继承BaseAgent

本文分析了Spring AI Alibaba Agent Framework中的A2aRemoteAgent实现,主要特点包括: 实现了Agent间的远程调用能力,支持分布式部署 核心组件包括AgentCard封装元数据、A2aNodeActionWithConfig处理调用逻辑、AgentCardProvider提供卡片管理 支持流式调用和状态共享机制 采用Builder模式构建Agent实例 通过指令传递实现Agent间通信 关键流程包括状态提取、请求构建、远程调用和状态更新四个步骤,形成Agent

820

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

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

Wang的专栏 402

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

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

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

Wang的专栏 349

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

hello-algo 计数排序源码解析:从简单计数到稳定排序的完整实现

计数排序(counting sort)是一种通过统计元素出现次数来完成的非比较排序算法。本篇基于 hello-algo 仓库中 [counting_sort.py](https://link.gitcode.com/i/bbb08f96916fbad0cb16308a6a467c5d) 的 Python 源码,讲解 `counting_sort_naive`(简单实现)与 `counting_so

gitblog_00141的博客 1073

7种排序算法动画详解:从冒泡到堆排序的实战指南

排序算法是编程基础中的核心知识,也是面试和实际开发中频繁使用的技能。《Hello 算法》项目提供了动画图解、一键运行的数据结构与算法教程,支持 Java, C++, Python 等多种语言,帮助开发者直观理解排序算法的工作原理。本文将通过动画图解方式,详细解析7种常用排序算法的实现过程、优缺点及适用场景,让你轻松掌握排序算法的精髓。 ## 排序算法概览:选择最适合你的排序方案 🚀 排序算法

gitblog_00974的博客 531

找回QQ空间历史说说,一次运行把旧日记录整理进Excel

某天你想翻回QQ空间主页,怎么都找不到三年前发的那条说说,八成不是它被删了,而只是不再展示。开源项目 GetQzonehistory 做的就是QQ空间历史说说找回:把旧说说、好友留言、转发记录分批取回,导出成 Excel 和网页文件,全部数据只留在你本地电脑,相当于完成一次QQ空间本地备份。 ## 🔎 旧说说其实还留在消息列表里 QQ空间主页只露出近期内容,就像只摊开最新几页的笔记本,可你和

gitblog_00021的博客 1072

如何在Hello Algorithm中验证算法正确性:三步测试完全指南

如果你刚接触算法学习,大概率遇到过这样的困惑:代码跑通了,但真的对吗?Hello Algorithm 提供动画图解和 15 种语言的可运行代码,而**算法测试**与**验证算法正确性**正是把它从"能跑"变成"可靠"的关键一步。本文带你用三个递进阶段完成验证,不堆代码,看完即可上手。 [![Hello Algorithm 数组数据结构示意图](https://raw.gitcode.com/Gi

gitblog_01143的博客 1082

GO01-Go 语言与主流编程语言深度对比

语言发布年份设计者类型系统编译/解释Go2009Google静态类型编译型Java1995Sun/Oracle静态类型编译+解释(JVM)Python1991动态类型解释型Rust2010Mozilla静态类型编译型C++1983静态类型编译型2009Ryan Dahl动态/静态解释型(V8)Kotlin2011JetBrains静态类型编译+解释(JVM)维度GoJavaPythonRustC++Node.js性能8/107/104/10。

技术博客 162

解密晶格数据结构:Anna KVS如何用数学原理解决分布式一致性难题

在分布式系统中,数据一致性是开发者面临的核心挑战。当多个节点同时读写数据时,如何确保结果的正确性和可靠性?GitHub加速计划旗下的Anna项目——一个低延迟云原生键值存储(KVS),创新性地引入**晶格数据结构**(Lattice Data Structures),通过数学原理优雅解决了这一难题。本文将深入解析Anna KVS如何利用晶格的幂等性、交换性和结合性,实现高效的分布式数据同步与冲突解

gitblog_00557的博客 809

Python数据结构选型实战:从时间复杂度到内存布局的工程决策

Python数据结构并非语法基础,而是影响性能、内存与可维护性的核心工程决策点。理解list的动态数组扩容机制、dict的紧凑哈希表内存布局、set的O(1)成员判断原理,是规避线上慢查询、内存泄漏和调试地狱的前提。技术价值在于将抽象复杂度转化为可测量的响应时间(如用deque替代list.pop(0)降低99.9%延迟)和可预估的内存开销(如tuple比list节省16字节元数据)。典型应用场景包括高并发在线状态服务的分层索引设计、爬虫去重的集合判存优化、金融风控中不可变数据契约保障。本文聚焦真实项目中的

weixin_34072458的博客 421

Slater:在SQLite中集成BM25与Graphiti,实现轻量级专业搜索

全文检索是处理海量文本数据、提升应用搜索体验的核心技术。其原理在于通过分词、建立倒排索引,将非结构化的文本转化为可快速查询的结构。BM25作为当前最先进的相关性排序算法,在传统TF-IDF基础上引入了文档长度归一化和词频饱和机制,能更精准地模拟人类对相关性的判断,从而显著提升搜索结果的质量。这项技术的价值在于,它让数据库层面的文本搜索具备了接近专业搜索引擎的智能排序能力,广泛应用于知识库、产品文档、内容社区等需要高效信息检索的场景。本文聚焦的Slater项目,正是通过将BM25算法与声明式查询语言Graph

weixin_30411819的博客 335
上一篇: 数据结构与算法之排序: 希尔排序 (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、付费专栏及课程。

余额充值