当前位置： 首页 > news >正文

Rust 练习册 ：深入探索可变长度数量编码

news 2025/11/10 8:02:42

在计算机科学和数据通信领域，高效的数据编码技术是实现高性能系统的关键。今天我们要探讨的是一个在现代数据格式中广泛使用的编码技术——可变长度数量编码（Variable Length Quantity，简称VLQ）。这种编码技术在MP3、MIDI、Protocol Buffers等众多标准中都有应用。通过Rust语言，我们将一起深入了解这种优雅而高效的编码方式。

问题背景

可变长度数量编码是一种用于表示任意大小整数的编码方法。与固定长度编码（如32位或64位整数）不同，VLQ根据数值的大小动态调整编码长度，使得小数值可以用较少的字节表示，从而节省存储空间和传输带宽。

VLQ的基本原理是：

  1. 将整数按7位一组进行分割
  2. 除了最后一组，其他组的最高位（MSB）设置为1，表示还有后续字节
  3. 最后一组的最高位设置为0，表示这是最后一个字节

例如：

  • 数值127 (0x7F) 编码为 [0x7F]
  • 数值128 (0x80) 编码为 [0x81, 0x00]
  • 数值16383 (0x3FFF) 编码为 [0xFF, 0x7F]

这种编码方式在需要表示大小不确定的整数时特别有用，比如在音乐文件中表示音符的持续时间，或在序列化协议中表示字段长度。

问题描述

我们的任务是实现两个函数：

#[derive(Debug, PartialEq)]
pub enum Error {IncompleteNumber,Overflow,
}/// Convert a list of numbers to a stream of bytes encoded with variable length encoding.
pub fn to_bytes(values: &[u32]) -> Vec<u8> {unimplemented!("Convert the values {:?} to a list of bytes", values)
}/// Given a stream of bytes, extract all numbers which are encoded in there.
pub fn from_bytes(bytes: &[u8]) -> Result<Vec<u32>, Error> {unimplemented!("Convert the list of bytes {:?} to a list of numbers", bytes)
}

第一个函数将u32数值列表编码为VLQ字节流，第二个函数将VLQ字节流解码为u32数值列表。

解决方案

让我们实现完整的VLQ编码和解码功能：

#[derive(Debug, PartialEq)]
pub enum Error {IncompleteNumber,Overflow,
}/// Convert a list of numbers to a stream of bytes encoded with variable length encoding.
pub fn to_bytes(values: &[u32]) -> Vec<u8> {let mut result = Vec::new();for &value in values {let mut encoded_bytes = Vec::new();let mut current_value = value;// 处理最低的7位encoded_bytes.push((current_value & 0x7F) as u8);current_value >>= 7;// 处理剩余的位while current_value > 0 {let byte = (current_value & 0x7F) as u8;encoded_bytes.push(byte | 0x80); // 设置最高位为1表示还有后续字节current_value >>= 7;}// 由于我们是从低位到高位处理的，需要反转字节顺序encoded_bytes.reverse();result.extend(encoded_bytes);}result
}/// Given a stream of bytes, extract all numbers which are encoded in there.
pub fn from_bytes(bytes: &[u8]) -> Result<Vec<u32>, Error> {let mut result = Vec::new();let mut i = 0;while i < bytes.len() {let mut value: u32 = 0;let mut continued = true;while continued && i < bytes.len() {let byte = bytes[i];// 检查是否会溢出u32if value > (u32::MAX >> 7) {return Err(Error::Overflow);}// 提取7位有效数据value = (value << 7) | ((byte & 0x7F) as u32);// 检查是否还有后续字节continued = (byte & 0x80) != 0;i += 1;}// 如果循环结束但仍然期待更多字节，则序列不完整if continued {return Err(Error::IncompleteNumber);}result.push(value);}Ok(result)
}

测试案例详解

通过查看测试案例，我们可以更好地理解函数的行为：

#[test]
fn to_single_byte() {assert_eq!(&[0x00], vlq::to_bytes(&[0x00]).as_slice());assert_eq!(&[0x40], vlq::to_bytes(&[0x40]).as_slice());assert_eq!(&[0x7f], vlq::to_bytes(&[0x7f]).as_slice());
}

小于128的数值只需要一个字节编码，且最高位为0。

#[test]
fn to_double_byte() {assert_eq!(&[0x81, 0x00], vlq::to_bytes(&[0x80]).as_slice());assert_eq!(&[0xc0, 0x00], vlq::to_bytes(&[0x2000]).as_slice());assert_eq!(&[0xff, 0x7f], vlq::to_bytes(&[0x3fff]).as_slice());
}

大于等于128的数值需要多个字节编码，除了最后一个字节，其他字节的最高位都为1。

#[test]
fn from_bytes() {assert_eq!(Ok(vec![0x7f]), vlq::from_bytes(&[0x7f]));assert_eq!(Ok(vec![0x2000]), vlq::from_bytes(&[0xc0, 0x00]));assert_eq!(Ok(vec![0x1f_ffff]), vlq::from_bytes(&[0xff, 0xff, 0x7f]));assert_eq!(Ok(vec![0x20_0000]),vlq::from_bytes(&[0x81, 0x80, 0x80, 0x00]));assert_eq!(Ok(vec![0xffff_ffff]),vlq::from_bytes(&[0x8f, 0xff, 0xff, 0xff, 0x7f]));
}

解码过程需要正确处理多字节序列。

#[test]
fn incomplete_byte_sequence() {assert_eq!(Err(vlq::Error::IncompleteNumber), vlq::from_bytes(&[0xff]));
}

以最高位为1的字节结尾的序列是不完整的。

#[test]
fn overflow_u32() {assert_eq!(Err(vlq::Error::Overflow),vlq::from_bytes(&[0xff, 0xff, 0xff, 0xff, 0x7f]));
}

超出u32范围的数值会导致溢出错误。

Rust语言特性运用

在这个实现中，我们运用了多种Rust语言特性：

  1. 枚举: 使用[Error]枚举表示可能的错误类型
  2. Result类型: 使用[Result]处理可能失败的操作
  3. 位运算: 使用位与(&)、位或(|)、右移(>>)等操作处理编码逻辑
  4. 向量操作: 使用[Vec]存储字节序列和数值列表
  5. 模式匹配: 使用[while]循环和条件判断处理解码过程
  6. 引用和切片: 正确处理 &[u32] 和 &[u8] 参数
  7. 错误处理: 通过返回[Result]类型安全地处理错误情况

算法原理深入

编码过程

VLQ编码的核心思想是将一个大整数分解为多个7位组：

  1. 从最低有效位开始，每7位分为一组
  2. 除了最后一组，其他组的最高位设置为1
  3. 最后一组的最高位设置为0，表示结束
  4. 由于我们从低位开始处理，最后需要反转字节顺序

解码过程

VLQ解码是编码的逆过程：

  1. 从字节流中逐个读取字节
  2. 提取每个字节的低7位作为有效数据
  3. 将这些数据按顺序组合成完整的数值
  4. 当遇到最高位为0的字节时，表示当前数值结束

算法复杂度分析

让我们分析实现的复杂度：

  • 时间复杂度:
    • 编码: O(n × log m)，其中n是数值个数，m是数值的平均大小
    • 解码: O(b)，其中b是字节数
  • 空间复杂度: O(b)，用于存储编码后的字节序列

实际应用场景

VLQ编码在许多实际场景中都有广泛应用：

  1. Protocol Buffers: Google的序列化协议使用VLQ编码整数字段
  2. MIDI文件: 音乐文件格式使用VLQ编码时间戳和长度信息
  3. MP3文件: 音频文件格式使用VLQ编码各种元数据
  4. 字体文件: OpenType等字体格式使用VLQ编码表长度
  5. 数据库系统: 某些数据库使用VLQ编码存储变长整数
  6. 网络协议: 各种网络协议使用VLQ编码长度前缀

优化版本

我们可以对实现进行一些优化：

/// 更高效的VLQ编码实现
pub fn to_bytes_optimized(values: &[u32]) -> Vec<u8> {// 预估所需容量以减少重新分配let mut result = Vec::with_capacity(values.len() * 4);for &value in values {if value < 128 {// 快速路径：单字节编码result.push(value as u8);} else {// 多字节编码let mut temp = [0u8; 5]; // u32最多需要5个字节let mut i = 4; // 从数组末尾开始temp[i] = (value & 0x7F) as u8;let mut current = value >> 7;while current > 0 {i -= 1;temp[i] = (current & 0x7F) as u8 | 0x80;current >>= 7;}result.extend_from_slice(&temp[i..]);}}result
}/// 更高效的VLQ解码实现
pub fn from_bytes_optimized(bytes: &[u8]) -> Result<Vec<u32>, Error> {let mut result = Vec::new();let mut i = 0;while i < bytes.len() {let mut value: u32 = 0;// 限制循环次数以防止溢出for _ in 0..5 {if i >= bytes.len() {return Err(Error::IncompleteNumber);}let byte = bytes[i];i += 1;// 检查溢出if value > (u32::MAX >> 7) {return Err(Error::Overflow);}value = (value << 7) | ((byte & 0x7F) as u32);// 如果最高位为0，表示结束if (byte & 0x80) == 0 {break;}}result.push(value);}Ok(result)
}

扩展功能

我们可以为这个系统添加更多功能：

/// 支持64位整数的VLQ编码
pub fn to_bytes_u64(values: &[u64]) -> Vec<u8> {let mut result = Vec::new();for &value in values {let mut temp = [0u8; 10]; // u64最多需要10个字节let mut i = 9;temp[i] = (value & 0x7F) as u8;let mut current = value >> 7;while current > 0 {i -= 1;temp[i] = (current & 0x7F) as u8 | 0x80;current >>= 7;}result.extend_from_slice(&temp[i..]);}result
}/// 流式解码，适用于大数据集
pub struct VlqDecoder<'a> {bytes: &'a [u8],position: usize,
}impl<'a> VlqDecoder<'a> {pub fn new(bytes: &'a [u8]) -> Self {Self {bytes,position: 0,}}pub fn next(&mut self) -> Result<Option<u32>, Error> {if self.position >= self.bytes.len() {return Ok(None);}let mut value: u32 = 0;for _ in 0..5 {if self.position >= self.bytes.len() {return Err(Error::IncompleteNumber);}let byte = self.bytes[self.position];self.position += 1;if value > (u32::MAX >> 7) {return Err(Error::Overflow);}value = (value << 7) | ((byte & 0x7F) as u32);if (byte & 0x80) == 0 {return Ok(Some(value));}}Err(Error::Overflow)}
}

与其他实现方式的比较

C语言实现

int encode_vlq(uint32_t value, uint8_t* buffer) {int i = 0;uint8_t temp[5];int pos = 4;temp[pos] = value & 0x7F;value >>= 7;while (value > 0) {pos--;temp[pos] = (value & 0x7F) | 0x80;value >>= 7;}while (pos <= 4) {buffer[i++] = temp[pos++];}return i;
}

Python实现

def to_bytes(values):result = bytearray()for value in values:temp = []temp.append(value & 0x7F)value >>= 7while value > 0:temp.append((value & 0x7F) | 0x80)value >>= 7temp.reverse()result.extend(temp)return bytes(result)

Rust的实现相比其他语言，具有内存安全、无运行时错误、编译时检查等优势，同时保持了与C语言相当的性能。

总结

通过这个练习，我们学习到了：

  1. 如何实现可变长度数量编码和解码算法
  2. 位运算在处理编码问题中的应用
  3. 使用Result类型进行安全的错误处理
  4. 算法优化和内存管理技巧
  5. 流式处理大数据集的方法
  6. Rust在系统编程方面的强大能力

VLQ编码问题虽然看起来复杂，但它涉及了位操作、错误处理和算法设计等多个方面。通过这个练习，我们不仅掌握了具体的实现技巧，也加深了对Rust语言特性的理解。

在实际应用中，这种编码技术广泛应用于各种数据格式和协议中。Rust的安全性和性能优势使得它成为实现这类底层编码功能的优秀选择。

这个练习也展示了Rust在处理低级位操作时的表达能力，通过类型系统和Result模式，我们可以编写出既安全又高效的代码。

http://www.dtcms.com/a/589103.html

相关文章：

  • dify二次开发部署服务器
  • webrtc降噪-NoiseEstimator类源码分析与算法原理
  • 4.3 Boost 库工具类 optional 的使用
  • 帮人做网站要怎么赚钱吗吉林平安建设网站
  • 文广网站建设sq网站推广
  • Nop平台拆分出核心部分nop-kernel
  • 结构型设计模式1
  • 普中51单片机学习笔记-中断
  • 二十六、STM32的ADC（DMA+ADC）
  • 网站开发的著作权和版权网站品牌推广
  • 【Docker】docker compose
  • 4.1.8 【2022 统考真题】
  • 深圳网站设计官网番禺人才网上
  • Tailwind CSS的Flex布局
  • 深入解析 LeetCode 1：两数之和
  • 重庆网站制作福州嘉兴网络科技有限公司
  • OpenCV(二十二)：图像的翻转与旋转
  • 权限维持：操作系统后门技术分析与防护
  • 网闸与防火墙：构建纵深防御的“门卫”与“断桥”
  • 室内设计找工作网站wordpress app源码
  • 河北seo网站优化公司光辉网站建设
  • android 网络访问拦截器使用后的bug处理
  • mysql视图和存储过程
  • VRRP的补充
  • 天津 交友 网站建设自建网站做外贸谷歌推广
  • Young GC 的触发时机
  • 专业做网站照片免费咨询法律律师电话号码
  • GAN vs. VAE：生成对抗网络 vs. 变分自编码机
  • Docker打包步骤
  • 【数据集+源码】基于yolov11+streamlit的玉米叶片病虫害检测系统