ASCII码与快速排序：从字符比较到排序算法实战解析-平芜编程栈

很多人刚开始学编程的时候，都在两件事上反复栽跟头：一个是字符比较，一个是排序算法。表面上看，前者背 ASCII 码表就够了，后者是经典的快速排序，两者各学各的似乎没什么关系。但真实项目里，它们经常连在一起出现——比如把一个字符串数组按字典序排序，比如统计一段英文文本中每个字符出现的次数再按 ASCII 顺序输出，比如写一个“自定义比较器”后发现顺序还是不对。

ASC 码表解决的是“数据用数字怎么表达”的问题，快速排序解决的是“数据怎么高效整理”的问题。把这两个知识点放在一起学，价值不是背会一张表、记住一段快排代码，而是理清一条完整链路：字符先变成可比较的数字，数字再通过排序算法重新排列，最后落到编程语言内置的排序函数或自己手写的 compare 逻辑上。文章会从字符比较的常见误区讲起，然后分别给出 C、Java、Python 三种快速排序实现，每一份代码都会结合 ASC 码排序场景做演示，最后补充工程中排序的最佳实践和排错思路。建议收藏备用，也可以把这篇文章当作一次“字符排序 + 分治算法”的综合复习。

1. 字符比较与排序：为什么两件事值得一起学

先看一个真实体验并不少见的现象：很多人在排序字符串数组时会得到类似["Banana", "apple", "Apple", "banana"]的结果，看起来“大写的排到了前面，但整体顺序又说不上来”。如果你把每个字符串开头字符对应的 ASCII 码值拿出来，比如A是 65，B是 66，a是 97，b是 98，排序结果就很容易解释了。

这说明一个容易忽略的前提：排序算法本身不关心比较的规则，它只负责找出“当前比较规则下的顺序”。也就是说，不管对象是整数、字符、字符串还是自定义对象，排序的过程都需要回答“两个元素谁大谁小”。一旦这个前置规则出了问题，后面用再高效的排序算法也会输出错误结果。

快速排序之所以值得单独拿出来练，不只是因为它是面试高频算法。它有三个特点对初学者理解深度很有帮助：第一，它把一个大问题拆成两个独立的小问题，递归处理，体现分治思想；第二，它不像冒泡排序那样需要反复遍历整串数据，平均时间可以做到 O(nlogn)，适合较大规模数据；第三，它是一类“内部交换式”排序，不申请额外的大数组，这对了解程序内存使用也有意义。

把 ASC 码表和快速排序串联起来的切入点是：ASC 码表决定字符的“原始大小”，快速排序决定一批字符在原始大小关系下如何重新组织。学习时可以先构造一份只包含大写字母的测试数组，用 C 语言排序并打印字符和 ASCII 值；再换成 Java 对字符串数组排序，体会对象排序中的 Comparable 机制；最后用 Python 的简洁写法对比空间开销。这样一轮下来，你既能动手验证字符比较规则，也能把快速排序的地基打牢。

2. ASCII 码表要点与容易踩的字符比较误区

2.1 ASCII 到底需要记住哪些

ASCII 全称是美国信息交换标准代码，用 7 位二进制表示 0 到 127 的字符，一共 128 个。其中真正在开发场景里高频出现的是数字、大写字母、小写字母和若干控制字符。下面这张表需要条件反射式记住，因为字符判断、字典序、大小写转换都会用到：

字符范围或名称	十进制范围或值	开发中的用途
数字`0`~`9`	48 ~ 57	判断字符是否为数字、将数字字符转成整数值
大写字母`A`~`Z`	65 ~ 90	判断字符是否为大写字母、字符串比较基础
小写字母`a`~`z`	97 ~ 122	判断字符是否为小写字母、大小写转换基础
空格	32	处理字符串空白、拆分词频时会遇到
换行符`\n`与回车符`\r`	10 和 13	处理文本行分隔
字符串结束符`\0`	0	C 语言字符串遍历终止条件

对于 C 语言新手，还有一个很容易混淆的点：字符'0'在内存里不是一个整数值 0，而是 48。如果直接把'0'当成整数参与运算，结果会出乎意料。反过来，整数 0 对应的是空字符'\0'，它也不是能直接打印成可见内容的字符。将数字字符转成整数时，正确做法是c - '0'；将整数转成数字字符时，正确做法是n + '0'。

2.2 字符比较的四个高频误区

误区一是认为字符'0'小于'A'。实际上按 ASCII 值看，'0'是 48，'A'是 65，所以'0' < 'A'成立。比较对象是字符本身时，许多编程语言会隐式比较它们的编码值，结果往往符合 ASCII 表顺序。

误区二是大小写字母之间差 32，所以可以用ch + 32或ch - 32来做大小写转换。但有前提：ch必须是字母。如果直接对一个数字字符或符号执行加减 32，会得到一个没有意义的字符。正确方式是先判断范围，例如if (c >= 'A' && c <= 'Z') c += 32;只把大写转成小写。

误区三是用字符编码顺序去理解中文拼音顺序。ASC 码表和扩展编码表只能表示字符编码层面的顺序，汉字按 Unicode 码点的排序并不等于拼音或笔画顺序。Java 或数据库如果直接把中文字符串按默认编码比较，结果通常不是中文用户预期的“按拼音排”。真正要做本地化文本排序，一般需要使用专门的语言排序规则，例如 Java 的Collator。这个话题和 ASC 码表并不直接连通，但它提醒人们：编码顺序只是底层比较规则，业务排序规则是另一层设计。

误区四是字符串比较并不是先比长度。如果两个字符串从左边第一个字符开始就比较出不同，比较结果立刻确定；只有前面所有字符都相同时，长度较长的字符串才更大。熟悉 ASC 码表之后，字符串比较可以理解为“逐个字符按编码值比较，直到分出大小或一方结束”。

2.3 用 C 程序查看字符串的 ASCII 值

理解字符比较最好直接用代码打印出每个字符的编码值。下面是一个最小 C 程序：

// 文件路径：sort-demo/ascii_demo.c #include <stdio.h> int main(void) { char text[] = "Hello"; for (int i = 0; text[i] != '\0'; i++) { printf("char = %c, ASCII = %d\n", text[i], (unsigned char)text[i]); } return 0; }

编译运行：

gcc ascii_demo.c -o ascii_demo ./ascii_demo

预期输出：

char = H, ASCII = 72 char = e, ASCII = 101 char = l, ASCII = 108 char = l, ASCII = 108 char = o, ASCII = 111

这里把字符强转成(unsigned char)是出于严谨性考虑：C 标准没有规定char是否有符号，如果处理扩展 ASCII 或二进制数据，直接以%d输出char可能打印负数。对标准 ASCII 字符在 0 到 127 范围内没有影响，但养成强转习惯能避免后面在处理高位字节时踩坑。

字符比较天然是数字比较，这为排序算法提供了统一入口。

3. 快速排序的工作机制：基准、分区与递归

快速排序的核心思路并不复杂：从一个区间里选一个基准值，把小于等于基准值的元素移到左边，把大于等于基准值的元素移到右边，这样基准值就落在它排序后真正该在的位置；然后对基准值左右两侧的子区间重复这个过程。

用一句话概括：每轮排序能让一个元素“归位”，并且把问题拆成两个更小的子问题。

举个例子，假设字母数组是["S", "O", "R", "T", "E"]，选定最后一个元素E作为基准。一轮分区后，所有小于E的字母都在左侧，大于E的都在右侧。由于 ASC 码顺序中其他字母都比E大，最终E会移到最左边，右侧剩下["S", "O", "R", "T"]继续递归排序。虽然这样看起来每轮只排好一个元素，但由于递归切割区间，总体效率远超冒泡排序。

分区方式常见的有两种：

维度	Lomuto 分区	Hoare 分区
实现思路	从前往后扫描，遇到小元素交换到前部	左右指针向中间移动，交换一对逆序对
代码易读性	代码短，适合讲解和面试快速手写	边界条件多，初学者容易写出越界
分区后基准位置	返回基准的准确位置	返回的是一个分割点，左右都不含基准
等值元素处理	要小心处理相等元素避免死循环	通常会把相等元素分散到两侧

实际选择哪种分区取决于你的目标。如果是面试手写干净版本，Lomuto 分区通常更容易在白板上写对；如果追求更少交换次数，Hoare 分区会合适一些，但需要更强的边界控制能力。

快速排序的平均时间复杂度是 O(nlogn)，最坏时间复杂度是 O(n^2)。最坏情况往往出现在“每次选到的基准都恰好是当前区间最小或最大值”的时候。一个典型的反例是：对已经排好序的数组，如果固定选最后一个元素作为基准，每次分区都只会切掉一个元素，递归深度会退化成 n，排序性能退化到和冒泡排序相近。这个问题出现时，递归深度也不再是预期的 O(logn)，极端情况下会导致栈溢出。这个问题会在后面的优化部分详细展开。

稳定性方面，快速排序通常是不稳定的。不稳定并不是说算法会有随机错误，而是指两个相等元素在排序前后的相对位置可能发生变化。对于只含字符的基础排序，影响不大；但如果在业务系统里先按部门分组再按薪资排序，相等的薪资记录可能会丧失之前的相对顺序，这时候如果业务要求保留原始次序，就应该优先考虑归并排序。

4. 三种语言的环境准备与代码入口

动手写代码前，先确认本机环境。这里不需要纠结最新版本，重点是工具链能用：

C 语言：Linux 或 macOS 自带gcc，Windows 可安装 MinGW-w64，也可以使用 Visual Studio 的开发者命令行。输入gcc --version能打印版本就说明环境可用。
Java：安装 JDK 8 及以上版本，命令行执行javac -version验证。注意 Java 文件名必须与公开类名一致，比如类名是QuickSort，保存的文件名必须是QuickSort.java。
Python：安装 Python 3 即可，命令行执行python3 --version验证。文本编辑器或 VS Code 都能运行，不需要额外安装第三方库。

建议建立这样一个目录结构，方便对照运行：

sort-demo/ ├── ascii_demo.c ├── quick_sort.c └── QuickSort.java

代码示例中的思路，重点在于理解排序和 ASC 码表的结合，而不是盲目追求复杂写法。下文会完整演示三种实现，并额外给出一份随机化优化片段，读者可以对照运行、修改输入数据、加入打印观察分区过程。

5. C 语言手写快速排序：对字符数组按 ASCII 排序

C 语言版本的快速排序最贴近计算机底层，也能顺带训练指针和数组的配合。下面代码使用 Lomuto 分区，固定选择当前区间最后一个元素作为基准。示例数据选择了一串大写字母，方便观察 ASC 码顺序。

// 文件路径：sort-demo/quick_sort.c #include <stdio.h> void swap(char arr[], int i, int j) { char temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } // Lomuto 分区：以 arr[high] 为基准 // 返回基准值最终所在的下标 int partition(char arr[], int low, int high) { char pivot = arr[high]; int i = low - 1; for (int j = low; j < high; j++) { if (arr[j] < pivot) { i++; swap(arr, i, j); } } swap(arr, i + 1, high); return i + 1; } void quick_sort(char arr[], int low, int high) { if (low < high) { int p = partition(arr, low, high); quick_sort(arr, low, p - 1); quick_sort(arr, p + 1, high); } } void print_array(char arr[], int len) { for (int i = 0; i < len; i++) { printf("%c ", arr[i]); } printf("\n"); } int main(void) { char arr[] = {'H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D'}; int len = sizeof(arr) / sizeof(arr[0]); printf("排序前："); print_array(arr, len); quick_sort(arr, 0, len - 1); printf("排序后："); print_array(arr, len); printf("对应 ASCII 值："); for (int i = 0; i < len; i++) { printf("%d ", (unsigned char)arr[i]); } printf("\n"); return 0; }

编译运行：

gcc quick_sort.c -o quick_sort ./quick_sort

预期输出：

排序前：H E L L O W O R L D 排序后：D E H L L L O O R W 对应 ASCII 值：68 69 72 76 76 76 79 79 82 87

代码里有两个关键细节值得反复思考：

第一，partition中pivot当成字符和arr[j]比较时，C 编译器会把它当作整数比较。这再次说明字符排序的底层就是整数排序。

第二，递归边界是if (low < high)。如果写成if (low <= high)或边界不正确，可能出现无限递归或数组越界。调试时可以打印low、high、partition返回值，观察区间是否每次都变小。

当数组含有多个相同元素，比如示例中有三个L和两个O，Lomuto 分区遇到相等元素并不会把它们全部放到某一边，而是会随机分散到两侧。这不影响最终正确性，因为后续递归依然会把相等元素放到正确区间内。需要特别注意的是，如果分区代码里用了“小于基准才交换”，那相等元素的处理可能造成i指针总是不前进，需要额外设计，而不是简单地漏掉等号比较。

6. Java 实现快速排序：用 Comparable 对字符串数组排序

Java 是面向对象语言，排序时经常不只是排char[]，而是排序String[]或者各种对象集合。因此这里给出一个泛型版本，所有元素类型都要求实现Comparable接口，这样比较逻辑可以交给元素自身定义。上层的快速排序算法只关心compareTo的结果是负数、0 还是正数。

// 文件路径：sort-demo/QuickSort.java import java.util.Arrays; public class QuickSort { public static <T extends Comparable<? super T>> void quickSort(T[] arr) { if (arr == null || arr.length == 0) { return; } quickSort(arr, 0, arr.length - 1); } private static <T extends Comparable<? super T>> void quickSort(T[] arr, int low, int high) { if (low < high) { int pivotIndex = partition(arr, low, high); quickSort(arr, low, pivotIndex - 1); quickSort(arr, pivotIndex + 1, high); } } private static <T extends Comparable<? super T>> int partition(T[] arr, int low, int high) { T pivot = arr[high]; int i = low - 1; for (int j = low; j < high; j++) { if (arr[j].compareTo(pivot) <= 0) { i++; swap(arr, i, j); } } swap(arr, i + 1, high); return i + 1; } private static <T> void swap(T[] arr, int a, int b) { T temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } public static void main(String[] args) { String[] names = { "banana", "Apple", "apple", "Banana", "cherry", "Cherry" }; System.out.println("排序前：" + Arrays.toString(names)); quickSort(names); System.out.println("排序后：" + Arrays.toString(names)); } }

编译运行：

javac QuickSort.java java QuickSort

预期输出：

排序前：[banana, Apple, apple, Banana, cherry, Cherry] 排序后：[Apple, Banana, Cherry, apple, banana, cherry]

这个结果对应着字符串第一个字符的 ASC 码值：大写A是 65，大写B是 66，大写C是 67，小写字母都在 97 到 122 区间，所以所有大写字母开头的字符串都会排在小写字母开头之前。这种顺序在 ASC 角度看完全正确，但用户常常觉得“为什么不是按字典的常见大小写无关顺序排序”。如果想实现忽略大小写的字典序，就要显式传入比较器，而不是依赖String默认的compareTo。

Java 里编写自定义比较时有一个容易踩的大坑：compare方法要求返回负数、0 或正数，但有人图省事直接写return a - b。如果a和b是很大的整数，相减可能溢出。更稳妥的写法是直接调用包装类的Integer.compare(a, b)或判断后用-1、1返回。这个细节不属于快速排序本身，却在实际业务代码中更容易引发隐蔽问题。

另一方面，真实工程里并不需要手写 QuickSort。JDK 的Arrays.sort对基本类型数组使用经过优化的双轴快速排序变体，对引用类型数组使用稳定排序实现；Collections.sort和List.sort也都能直接对集合排序。手写快排的意义在于理解分治与递归边界，以及当数据量、内存和稳定性要求特殊时能判断为什么调库是更好的选择。

7. Python 快速排序：简洁版与原地版差距在哪里

Python 的代码容易让初学者误以为排序只有短短几行。其实常用写法有“简洁版”和“原地版”两种，它们的时间和空间表现并不一样，需要分开讲。

7.1 简洁版：可读性优先但有额外空间开销

# 文件路径：sort-demo/quick_sort_simple.py def quick_sort_simple(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort_simple(left) + middle + quick_sort_simple(right) if __name__ == "__main__": sample = list("HELLOWORLD") print("排序前：", sample) print("排序后：", quick_sort_simple(sample))

运行输出：

排序前：['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D'] 排序后：['D', 'E', 'H', 'L', 'L', 'L', 'O', 'O', 'R', 'W']

这个版本把“把小于基准的元素放左边、把等于基准的元素放中间、把大于基准的元素放右边”直接翻译成列表推导式，和快速排序语义几乎一一对应，非常适合演示分治思想。但它每次递归都会创建新的left、right列表，最终拼接整个数组，所以空间复杂度不是 O(logn) 或 O(n) 里更优的那种，而更像是“完整复制式”的实现。对入门理解没问题，如果拿去排序百万级数据，内存开销会比原地版大不少。

Python 的字符比较同样基于 Unicode 码点。ASCII 字符在 Unicode 表中沿用了原有码位，所以大写字母依然排在小写字母前。

7.2 原地版：更接近 C 语言的双指针分区

# 文件路径：sort-demo/quick_sort_inplace.py def quick_sort_inplace(arr, low=0, high=None): if high is None: high = len(arr) - 1 if low >= high: return pivot = arr[(low + high) // 2] i = low j = high while i <= j: while arr[i] < pivot: i += 1 while arr[j] > pivot: j -= 1 if i <= j: arr[i], arr[j] = arr[j], arr[i] i += 1 j -= 1 quick_sort_inplace(arr, low, j) quick_sort_inplace(arr, i, high) if __name__ == "__main__": sample = list("HELLOWORLD") print("排序前：", sample) quick_sort_inplace(sample) print("排序后：", sample)

这个版本和 C 版思想一致，但要注意几点：

pivot = arr[(low + high) // 2]选取中间元素，能规避“数组已经有序时固定选最后一个元素导致严重退化”的常见问题。
内部循环使用的是arr[i] < pivot和arr[j] > pivot，而不是<=或>=。因为如果遇到相等元素也继续移动指针，才不至于在一个所有元素都相等的数组里死循环。
当i <= j时执行交换，同时让i加一、j减一，保证区间缩小。

原地版的空间开销主要来自递归调用栈，平均情况下是 O(logn)，比简洁版的完整复制要好很多，也更接近真实算法题里的手写要求。选择哪个版本取决于目标：想快速理解递归逻辑用简洁版，想理解排序的本质和内存消耗用原地版。

8. 运行结果与正确性验证方式

写完排序代码后，不能只看一次输出就认为万事大吉。一个常见建议是准备一个排序检查函数，用多种边界数据反复验证。

# 文件路径：sort-demo/verify_sort.py def is_sorted(arr): return all(arr[i] <= arr[i + 1] for i in range(len(arr) - 1)) def quick_sort_inplace(arr, low=0, high=None): if high is None: high = len(arr) - 1 if low >= high: return pivot = arr[(low + high) // 2] i = low j = high while i <= j: while arr[i] < pivot: i += 1 while arr[j] > pivot: j -= 1 if i <= j: arr[i], arr[j] = arr[j], arr[i] i += 1 j -= 1 quick_sort_inplace(arr, low, j) quick_sort_inplace(arr, i, high) if __name__ == "__main__": cases = [ [], ["a"], ["E", "D", "C", "B", "A"], ["A", "A", "A", "A"], ["apple", "Apple", "banana", "Banana", "cherry"], ] for sample in cases: quick_sort_inplace(sample) print("排序结果：", sample, "是否有序：", is_sorted(sample))

这里至少覆盖了四类经典场景：空列表、单元素列表、逆序列表、全部相等的列表，以及大小写混合字符串。快速排序容易在“全部相等”这个场景出错，如果分区代码里没有正确处理等值元素，可能无限循环或交换失败。验证函数会把是否有序的结果打印出来，帮你快速判断算法是否基本正确。

如果要进一步验证排序稳定性，快速排序本身就不是稳定排序，不能依赖它保留相同元素的原始顺序。需要稳定排序时请换成归并排序或 Java 的Arrays.sort对引用类型数组的默认实现。

C 语言版本也可以用类似思路进行自查，但最简单的方法是打印排序后的相邻字符，判断是否存在前者 ASCII 值大于后者的相邻对。实际代码里也可以在排序后加一段循环判断：

int sorted = 1; for (int i = 0; i < len - 1; i++) { if ((unsigned char)arr[i] > (unsigned char)arr[i + 1]) { sorted = 0; break; } } printf("是否有序：%s\n", sorted ? "true" : "false");

把“肉眼观察”替换成“程序判断”，是减少测试误判的第一步。

接下来需要关注快速排序在工程中可能碰到的性能退化问题。前面 C 版本固定选最后一个元素作为基准，对已经排好序的数组会退化成 O(n^2) 并产生很深的递归。一个常用的优化是随机选基准，再把基准交换到末尾，这样从概率上降低最坏情况发生的可能性。下面是 C 语言随机化版本的优化片段：

// 快速排序随机化优化片段 #include <stdlib.h> #include <time.h> int random_pivot_index(int low, int high) { return low + rand() % (high - low + 1); } void quick_sort_random(char arr[], int low, int high) { if (low < high) { int pivotPos = random_pivot_index(low, high); swap(arr, pivotPos, high); int p = partition(arr, low, high); quick_sort_random(arr, low, p - 1); quick_sort_random(arr, p + 1, high); } }

调用前先执行一次srand((unsigned int)time(NULL));做随机种子初始化。随机化能避免极端有序输入导致固定最坏情况下递归过深，但不能保证 100% 性能稳定。另一个常见优化是三数取中，即在low、mid、high三个位置取中间值作为基准，无需引入随机数，实际效果往往也不错。无论选择哪种优化，核心目标都是让每一轮分区后的左右两个子区间尽量接近一半。

9. 快速排序常见问题与排查思路

手写快速排序最容易出错的不是“思想”，而是边界和比较条件。下面把常见问题和排查方法汇总成一张表，方便直接对照使用：

问题现象	可能原因	排查方式	解决方案
程序直接崩溃或报越界	递归边界错误，区间大小没有变小的趋势	打印每次递归的 low、high、分区返回值	检查`if (low >= high) return`；确认交换后 i、j 更新合理
排序输出未完全有序	分区后基准位置被错误地再次参与递归	打印每轮分区后数组的内容	左递归只排基准左侧，右递归只排基准右侧
数组元素有丢失或重复覆盖	swap 下标传入错误	检查数组下标是否越界，打印 swap 前后的下标	用数组名和两个下标封装 swap，避免直接写复杂交换逻辑
全部元素相等时死循环	内层循环遇到相等元素一直停止不前	用`["A", "A", "A"]`测试	内层要使用`<`和`>`跳过相等元素，而不是`<=`、`>=`
固定取末尾基准时已排序数组性能极差	每次只删除一个元素，退化到 O(n^2)	统计递归次数或直接跑大数据量观察耗时	使用随机基准或三数取中
Java 泛型数组无法直接创建	不能直接`new T[]`	检查编译器报错	统一使用传入的类型数组，或通过`Arrays.copyOf`间接处理
Java 默认排序结果不满足字典习惯	默认按字符编码值比较，大写字母都小于小写字母	用`Collator`或`String.CASE_INSENSITIVE_ORDER`比较	明确指定业务期望的比较规则
Python 简洁版内存占用偏高	每次递归创建大量新列表	在代码里打印递归深度或对象数量	数据量大时换成原地双指针版本

问题排查时最重要的原则是“先确认比较规则，再确认分区逻辑”。如果你排的是字符串数组，先检查compareTo或compare的返回结果是否完全符合预期；如果你排的是字符数组，先用本章的ascii_demo.c输出每个元素的 ASCII 值。排序算法本身的递归、交换逻辑可以被测试函数验证，但比较规则错误往往不是通过“多跑几个乱序用例”能发现的。

10. 最佳实践：从“会写快排”到“会选排序”

很多初学者觉得“必须自己实现排序算法才算懂”，进入真实项目后又觉得“反正调库就行，不用管底层”。两个判断都比较片面。更容易带来长期收益的做法是：既能把快速排序的递归版本写出来、能讲清楚为什么退化、能完成随机化优化，又清楚什么时候不该自己造轮子。

不同场景下适合的排序工具不同：

场景	推荐方式	说明
C 语言普通数组排序	标准库`qsort`	需要传入比较函数指针
C++ 容器排序	`std::sort`	默认使用快速排序或混合排序，需保证随机访问迭代器
Java 基本类型数组排序	`Arrays.sort`	JDK 对基本类型实现优化后的双轴快速排序变体
Java 引用类型数组排序	`Arrays.sort`	默认稳定排序，适合保留相同元素相对顺序
Python 列表排序	`sorted()`或`list.sort()`	默认 TimSort，稳定且能接收 key 自定义比较逻辑
需要保留相等元素原有顺序	不要使用快速排序	改用归并排序或 TimSort 思想实现的排序

如果你在面试中手写快速排序，核心考察点通常会落在三个地方：分区函数是否能正确返回基准位置；递归边界是否清晰；等值元素和大数组退化问题是否有意识去处理。因此在练习时可以从 Lomuto 分区入手，把partition里小于基准比较改成小于等于基准并测试会有什么后果，再改成 Hoare 分区，观察代码复杂度和 bug 率变化。

在业务代码里写比较逻辑时，有几个通用原则值得记住：