2026-04-20：二进制反射排序。用go谈话，把数组里每个数先转成二进制；对它的二进制示意作念“二进制反射”（把二进制位从左到右反过来，前导零不计入）；再把反射后的二进制串转回十进制，这个适度等于该元素的“反射值”。
然后按总共元素的反射值从小到大排序；若两个数的反射值换取，则比拟它们原始的数值大小，原数更小的排在前边。
终末复返排序后的数组。
1
1
输入： nums = [3，6，5，8]。
输出： [8，3，6，5]。
确认：
二进制反射值为：
3 -> (二进制) 11 -> (回转) 11 -> 3
6 -> (二进制) 110 -> (回转) 011 -> 3
5 -> (二进制) 101 -> (回转) 101 -> 5
8 -> (二进制) 1000 -> (回转) 0001 -> 1
把柄反射值排序为 [8， 3， 6， 5]。
驻扎，3 和 6 的反射值换取，因此需要按原始值的升序罗列。
题目来独力扣3769。
二进制反射排序齐备过程详解
第一步：明确中枢界说
1. 二进制调遣：把每个十进制数字转为无前导零的二进制字符串
2. 二进制反射：将二进制字符串合座回转，忽略回转后产生的前导零，再转回十进制，得到反射值
3. 排序轨则：
• 优先按反射值从小到大排序
• 反射值换取期，按原始数值从小到大排序
第二步：一一筹备每个数字的反射值
咱们对数组 [3， 6， 5， 8] 中的每个元素，循序筹备反射值：
1. 数字 3
• 十进制 → 二进制（无前导零）：11
• 二进制反射（回转）：11
• 回转后转回十进制：3
• 反射值 = 3，原始值 = 3
2. 数字 6
• 十进制 → 二进制（无前导零）：110
• 二进制反射（回转）：011（忽略前导零 → 11）
• 回转后转回十进制：3
• 反射值 = 3，原始值 = 6
3. 数字 5
• 十进制 → 二进制（无前导零）：101
• 二进制反射（回转）：101
• 回转后转回十进制：5
• 反射值 = 5，原始值 = 5
4. 数字 8
• 十进制 → 二进制（无前导零）：1000
• 二进制反射（回转）：0001（忽略前导零 → 1）
• 回转后转回十进制：1
• 反射值 = 1，原始值 = 8
第三步：整理总共元素的「反射值+原始值」
整理后适度：
• 8：反射值 1，原始值 8
• 3：反射值 3，原始值 3
• 6：反射值 3，开云sports原始值 6
• 5：反射值 5，原始值 5
第四步：按照排序轨则排序
1. 第一优先级：反射值升序
反射值大小：1
是以 8（1）排第一，5（5）排终末；3 和 6 反射值王人是 3，比肩中间。
2. 第二优先级：反射值换取期，原始值升序
第五步：得到最终适度
排序后数组：[8， 3， 6， 5]
时分复杂度 & 稀薄空间复杂度分析
1. 时分复杂度
• 中枢操作是自界说排序，Go 谈话 slices.SortFunc 底层使用快速排序/优化排序，时分复杂度为 O(n log n)（n 是数组长度）。
• 排序过程中，每个元素管帐算一次反射值，筹备反射值是固定位数的二进制操作（常数时分 O(1)）。
• 总时分复杂度：O(n log n)。
2. 稀薄空间复杂度
• 代码径直在原数组上进行排序，莫得创建新的数组存储数据。
• 排序和筹备反射值仅使用了常数个临时变量。
• 总数外空间复杂度：O(1)（原地操作，常数空间）。
追想
1. 齐备现实经过：筹备每个数的二进制→二进制回转→筹备反射值→按反射值排序→反射值换取按原数排序→输出适度
2. 时分复杂度：O(n log n)
3. 稀薄空间复杂度：O(1)（原地排序，无稀薄数组支出）
Go齐备代码如下：
package main
import (
"cmp"
"fmt"
"math/bits"
"slices"
)
func sortByReflection(nums []int) []int {
slices.SortFunc(nums， func(a， b int)int {
revA := int(bits.Reverse(uint(a)) >> bits.LeadingZeros(uint(a)))
revB := int(bits.Reverse(uint(b)) >> bits.LeadingZeros(uint(b)))
return cmp.Or(revA-revB， a-b)
})
return nums
}
func main {
nums := []int{3， 6， 5， 8}
result := sortByReflection(nums)
fmt.Println(result)
}
Python齐备代码如下：
# -*-coding:utf-8-*-
def sort_by_reflection(nums):
def reverse_bits(n):
# 将整数调遣为二进制字符串，回转并去掉末尾的0
if n == 0:
return0
# 获取二进制示意（去掉'0b'前缀）
binary = bin(n)[2:]
# 回转字符串
reversed_binary = binary[::-1]
# 调遣为整数
returnint(reversed_binary， 2)
def sort_key(num):
rev = reverse_bits(num)
# Python的排序是相识的，咱们通过复返元组来收场多级排序
return (rev， num)
# 使用sort要害进行原地排序
nums.sort(key=sort_key)
return nums
def main:
nums = [3， 6， 5， 8]
result = sort_by_reflection(nums)
print(result)
if __name__ == "__main__":
main
C++齐备代码如下：
#include
#include
#include
#include
#include
int reverseBits(int n) {
if (n == 0) return0;
unsigned int u = static_cast(n);
// C++23 提供 std::bit_reverse
// 要是编译器撑抓，不错使用：#if __cpp_lib_bit_reverse
// 不然使用手动收场
// 手动收场32位回转
u = ((u & 0x55555555) > 1);
u = ((u & 0x33333333) > 2);
u = ((u & 0x0F0F0F0F) > 4);
u = ((u & 0x00FF00FF) > 8);
u = (u > 16);
return static_cast(u);
}
int leadingZeros(int n) {
if (n == 0) return32;
return std::countl_zero(static_cast(n));
}
std::vector sortByReflection(std::vector& nums) {
std::ranges::sort(nums， [](int a， int b) {
int revA = reverseBits(a) >> leadingZeros(a);
int revB = reverseBits(b) >> leadingZeros(b);
if (revA != revB) {
return revA
}
return a
});
return nums;
}
int main {
std::vector nums = {3， 6， 5， 8};
std::vector result = sortByReflection(nums);
for (size_t i = 0; i
std::cout
}
std::cout
return0;
}
咱们坚信东谈主工智能为平庸东谈主提供了一种“增强器具”，并致力于于共享全概念的AI学问。在这里，您不错找到最新的AI科普著述、器具评测、耕作效果的隐私以及行业瞻念察。
接待情切“福大大架构师逐日一题”开云sports，发音信可赢得口试府上，让AI助力您的改日发展。
凯发娱乐(K8)官方网站
备案号: