在编程的世界里数据就像一堆散落在地上的积木，杂乱无章。而排序算法，就是那双神奇的手，Neng将这些积木按照大小、颜色或规则整齐地码放好。无论你是刚入门的“萌新”，还是久经沙场的“老司机”，十大经典排序算法dou是绕不开的必修课。今天我们就抛开枯燥的教科书定义，用geng感性、geng贴近实战的视角，重新审视这十种让无数程序员“爱恨交织”的算法逻辑。

在正式开始之前，我们需要先达成一个共识：排序算法虽然种类繁多，但并非无迹可寻。根据其核心思想，我们通常将其划分为两大阵营：基于比较的排序和基于非比较的排序。前者像是在天平上不断称重，后者则geng像是分类归档。准备好了吗？让我们开启这场算法之旅。

一、简单直观的“入门三剑客”

对于初学者来说理解算法逻辑的第一步至关重要。下面这三种算法，虽然性Neng上未必是Zui优的，但它们胜在逻辑简单，是理解排序思想的基石。

1. 冒泡排序：像水中的气泡一样上浮

想象一下在平静的湖底，有一串大小不一的气泡。因为浮力的作用，大的气泡总是争先恐后地往水面上窜。冒泡排序正是利用了这种朴素的物理直觉。

它的核心逻辑非常直接：在每一轮遍历中，我们让相邻的两个元素进行“较量”。Ru果左边的比右边大，就交换它们的位置。这样一来每一轮遍历结束后当前未排序部分里Zui大的那个元素，就会像气泡一样，“慢悠悠”地浮到数组的末尾。虽然过程有点像蜗牛爬，但只要数组有序了我们就Ke以通过设置一个标记位，提前终止循环，稍微挽回一点面子。

Java代码实现

public class BubbleSort {
    public static void bubbleSort {
        // 边界检查，别让空指针坑了你
        if  return;
        int n = arr.length;
        boolean swapped; // 这是一个“哨兵”，用来监听是否发生了交换
        for  {
            swapped = false;
            // 每一轮，末尾的i个元素其实Yi经归位了不用再管
            for  {
                if  {
                    // 既然左边比右边大，那就换个位
                    int temp = arr;
                    arr = arr;
                    arr = temp;
                    swapped = true;
                }
            }
            // Ru果这一轮跑下来连一次交换dou没发生，说明数组早就排好了
            if  break;
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        bubbleSort;
        System.out.println); // kankan结果，是不是变乖了？
    }
}

算法点评

时间复杂度： Zui好的情况是O，Zui坏和平均情况则是O。说实话，数据量大时它真的有点慢。

空间复杂度： O，毕竟是在原地折腾，没占什么额外地盘。

稳定性： 稳定。相等元素不会因为交换而改变相对顺序。

2. 选择排序：挑选“标兵”的过程

Ru果说冒泡排序是“推着”大元素往后走，那么选择排序就是“盯着”小元素往前拉。它的逻辑就像是在操场上排队：每次从未排好队的人群里挑出个子Zui小的那个，让他站到队伍的Zui前面。

这个过程虽然简单粗暴，但效率确实让人着急。因为无论数组原本是不是有序，它dou要老老实实地把每个位置dou扫描一遍，找出Zui小值。这种“一根筋”的特质，注定了它在性Neng上难以有大的突破。

Java代码实现

public class SelectionSort {
    public static void selectionSort {
        if  return;
        int n = arr.length;
        for  {
            int minIndex = i; // 先假设当前位置是Zui小的
            // 去后面找找，kan有没有比它geng小的
            for  {
                if  {
                    minIndex = j; // 发现geng小的，geng新索引
                }
            }
            // Ru果找到的Zui小值不是当前位置，那就交换
            if  {
                int temp = arr;
                arr = arr;
                arr = temp;
            }
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        selectionSort;
        System.out.println);
    }
}

算法点评

时间复杂度： 无论数据好坏，统统O。这种稳定性也是没谁了。

空间复杂度： O，原地操作。

稳定性： 不稳定。比如第一个5会和2交换，这就破坏了原本两个5的顺序。

3. 插入排序：像打扑克时理牌

你玩过扑克牌吗？当你抓起一张新牌时是不是习惯性地把它插到手里Yi有牌列的合适位置？插入排序正是模仿了这个动作。

它默认数组的前面部分是有序的，然后取出下一个元素，从后往前扫描，把它插到前面有序序列中恰当的位置。虽然听起来动作hen多，但在数据量hen小或者基本有序的情况下它的表现甚至比那些复杂的O算法还要好。这也是为什么hen多高级排序在处理小规模数据时dou会退回到插入排序的原因。

Java代码实现

public class InsertionSort {
    public static void insertionSort {
        if  return;
        int n = arr.length;
        for  {
            int current = arr; // 拿起这张新牌
            int j = i - 1;
            // 往前找，比它大的dou往后挪一步
            while  {
                arr = arr;
                j--;
            }
            // 找到坑位了把新牌放进去
            arr = current;
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        insertionSort;
        System.out.println);
    }
}

算法点评

时间复杂度： Zui好O，Zui坏和平均O。

空间复杂度： O。

稳定性： 稳定。

二、效率至上的“进阶四巨头”

当数据量成千上万时简单的O算法就显得力不从心了。这时候，我们需要动用一些geng高级的策略，比如分治法、二叉树等，将复杂度压低到O级别。

4. 希尔排序：带步长的“跳跃式”插入

希尔排序是插入排序的“魔改版”。它觉得普通插入排序每次只Neng移动一位太慢了于是发明了“步长”的概念。

它先设定一个较大的步长，将数组中相隔较远的元素分成一组，进行粗略的排序。随着步长逐渐减小，直到步长为1时数组Yi经基本有序了Zui后再Zuo一次标准的插入排序。这种“先宏观后微观”的策略，极大地减少了元素移动的次数，效率提升非常明显。

Java代码实现

public class ShellSort {
    public static void shellSort {
        if  return;
        int n = arr.length;
        // 步长从一半开始，每次减半
        for  {
            // 对每个分组进行插入排序
            for  {
                int current = arr;
                int j = i - step;
                // 同一组内的元素比较
                while  {
                    arr = arr;
                    j -= step;
                }
                arr = current;
            }
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        shellSort;
        System.out.println);
    }
}

算法点评

时间复杂度： 这个比较复杂，取决于步长的选择，平均大概在O左右。

空间复杂度： O。

稳定性： 不稳定。因为相同的元素可Neng被分到不同的组里导致相对顺序改变。

5. 归并排序：分而治之的艺术

归并排序是“分治法”的教科书式案例。它的核心思想是：把一个大问题拆成两个小问题，分别解决，然后把结果合并起来。

具体到排序上，它先把数组从中间劈开，递归地把左半边和右半边dou排好序，Zui后再把这两个有序的子数组合并成一个大的有序数组。这种逻辑非常优雅，且无论数据如何，它的性Nengdou极其稳定。唯一的缺点是它需要额外的空间来存放临时数据，有点“以空间换时间”的味道。

Java代码实现

public class MergeSort {
    public static void mergeSort {
        if  return;
        int temp = new int; // 提前准备好临时空间
        mergeSort;
    }
    private static void mergeSort {
        if  return;
        int mid = left +  / 2;
        mergeSort; // 左边归并
        mergeSort; // 右边归并
        merge; // 合并
    }
    private static void merge {
        int i = left;
        int j = mid + 1;
        int k = 0;
        // 比较左右两部分的元素，谁小放谁
        while  {
            if  {
                temp = arr;
            } else {
                temp = arr;
            }
        }
        // 把剩下的元素扫进去
        while  temp = arr;
        while  temp = arr;
        // 把临时数组拷回原数组
        for  {
            arr = temp;
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        mergeSort;
        System.out.println);
    }
}

算法点评

时间复杂度： 无论何时dou是O，非常稳。

空间复杂度： O，那个临时数组是逃不掉的。

稳定性： 稳定。在合并的时候，我们特意用了`<=`来保证左边元素的优先权。

6. 快速排序：当之无愧的“速度之王”

快速排序是当之无愧的明星。它也是分治思想的应用，但策略geng激进：选一个“基准值”，然后把数组分成“比基准小”和“比基准大”两部分，递归处理。

快排的灵魂在于“分区”。为了防止Zui坏情况导致性Neng退化到O，我们通常会随机选择基准值。虽然它的平均时间复杂度也是O，但它的常数因子比归并排序小，实际运行起来往往geng快。

Java代码实现

import java.util.Arrays;
import java.util.Random;
public class QuickSortOptimized {
    private static final Random RANDOM = new Random;
    public static void quickSort {
        if  return;
        quickSort;
    }
    private static void quickSort {
        if  return;
        int pivotIndex = partition;
        quickSort;
        quickSort;
    }
    private static int partition {
        // 随机选个基准，防止被特殊数据“卡死”
        int randomIndex = left + RANDOM.nextInt;
        swap;
        int pivot = arr;
        int i = left;
        int j = right;
        while  {
            // 先从右往左找比基准小的
            while  j--;
            // 再从左往右找比基准大的
            while  i++;
            if  swap;
        }
        // Zui后把基准归位
        swap;
        return i;
    }
    private static void swap {
        int temp = arr;
        arr = arr;
        arr = temp;
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        quickSort;
        System.out.println);
    }
}

算法点评

时间复杂度： 平均O，Zui坏O。

空间复杂度： O，主要是递归栈的开销。

稳定性： 不稳定。分区时的交换操作hen容易打乱相等元素的顺序。

7. 堆排序：利用二叉树的智慧

堆排序听起来hen高深，其实原理hen有趣。它利用了“堆”这种数据结构的特性：堆顶元素永远是Zui大的。

它的操作流程是：先把数组构建成一个大顶堆，然后把堆顶元素和数组末尾的元素交换，接着把剩下的元素重新调整成堆。重复这个过程，就像从金字塔顶端不断把Zui大的砖块抽走，Zui后剩下的自然就是有序的了。堆排序是原地排序，不需要额外空间，这点比归并排序强。

Java代码实现

public class HeapSort {
    public static void heapSort {
        if  return;
        int n = arr.length;
        // 第一步：建堆
        for  {
            heapify;
        }
        // 第二步：逐个取出堆顶
        for  {
            swap; // 把Zui大的放到末尾
            heapify; // 重新调整剩下的堆
        }
    }
    private static void heapify {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if  largest = left;
        if  largest = right;
        if  {
            swap;
            heapify; // 递归调整
        }
    }
    private static void swap {
        int temp = arr;
        arr = arr;
        arr = temp;
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        heapSort;
        System.out.println);
    }
}

算法点评

时间复杂度： 所有情况dou是O。

空间复杂度： O，原地排序。

稳定性： 不稳定。

三、非比较排序的“特种部队”

前面提到的算法dou离不开“比较”二字。但Ru果数据的范围hen有限，我们完全Ke以跳过比较，直接通过统计或映射来排序。这类算法往往Neng达到线性的时间复杂度O，堪称“降维打击”。

8. 计数排序：数数就Neng排好序

计数排序的逻辑简单到令人发指：统计每个数字出现了几次然后按顺序把数字填回去。

比如你要给全班同学的考试分数排序，分数范围是0-100。那你只需要开一个长度为101的数组，统计每个分数有多少人，然后按顺序输出即可。它不需要比较，效率极高，但前提是数据的范围不Neng太大，否则会非常浪费空间。

Java代码实现

public class CountingSort {
    public static void countingSort {
        if  return;
        int max = arr, min = arr;
        for  {
            if  max = num;
            if  min = num;
        }
        // 根据Zui大Zui小值确定计数数组的大小
        int count = new int;
        // 开始数数
        for  {
            count++;
        }
        // 把数填回原数组
        int index = 0;
        for  {
            while  {
                arr = i + min;
                count--;
            }
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        countingSort;
        System.out.println);
    }
}

算法点评

时间复杂度： O，k是数据的范围。

空间复杂度： O。

稳定性： 稳定。

9. 桶排序：分而治之的“收纳术”

桶排序是计数排序的升级版。它把数据分到若干个“桶”里每个桶负责一个区间范围。然后对每个桶内部的元素进行排序，Zui后把所有桶里的数据倒出来拼接在一起。

这就像整理衣服：先把它们按颜色扔进不同的篮子，再在每个篮子里叠衣服。Ru果数据分布非常均匀，桶排序的效率极高。

Java代码实现

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class BucketSort {
    public static void bucketSort {
        if  return;
        int n = arr.length;
        // 1. 找出Zui大Zui小值
        int max = arr, min = arr;
        for  {
            if  max = num;
            if  min = num;
        }
        // 2. 创建桶
        int bucketNum = n;
        List buckets = new ArrayList<>;
        for  {
            buckets.add);
        }
        // 3. 元素入桶
        for  {
            int index =  *  / ;
            buckets.get.add;
        }
        // 4. 桶内排序并合并
        int index = 0;
        for  {
            Collections.sort; // 这里偷懒用了系统自带的排序
            for  {
                arr = num;
            }
        }
    }
    public static void main {
        int arr = {5, 1, 4, 2, 8};
        bucketSort;
        System.out.println);
    }
}

算法点评

时间复杂度： 平均O，取决于桶的数量和排序方式。

空间复杂度： O。

稳定性： 取决于桶内排序算法，通常Ke以Zuo到稳定。

10. 基数排序：按位数的“多级分类”

基数排序有点像桶排序的变种，但它不是按数值范围分桶，而是按“位数”来分。比如一组数字，先按个位的大小排一遍，再按十位排一遍，Zui后按百位排一遍。

这种“低位优先”的策略听起来hen神奇，但确实有效。它不需要比较数字的大小，只需要按位分发。当然它只Neng处理整数或特定格式的字符串。

算法点评

时间复杂度： O)，d是数字的位数。

空间复杂度： O。

稳定性： 稳定。

没有Zui好的算法，只有Zui合适的场景

一口气kan完了这十大排序算法，是不是感觉脑子有点“过载”？别担心，理解它们需要时间。在实际开发中，我们hen少需要自己去手写这些算法，但理解它们的底层原理，Neng帮你Zuo出geng明智的技术选型。

比如数据量小且基本有序时插入排序可Neng比快排还快；数据量巨大且内存有限时堆排序是个不错的选择；而数据范围有限且追求极致速度时计数排序则是神器。编程不仅仅是写代码，geng是在权衡与取舍中寻找Zui优解的艺术。希望这篇文章Neng帮你理清思路，在未来的代码江湖中，游刃有余！

---