经典排序算法

最新推荐文章于 2026-06-24 08:42:37 发布
原创 最新推荐文章于 2026-06-24 08:42:37 发布 · 1.2k 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#排序算法 #算法 #java

算法分类

  • 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
  • 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
  • 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
  • 空间复杂度：是指算法在计算机

算法复杂度

排序详解

1.冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

1.2 动图演示

1.3 代码实现

public class BubbleSort {
    
    // 冒泡排序方法
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        // 外层循环控制排序轮数
        for (int i = 0; i < n - 1; i++) {
            // 内层循环控制每轮比较次数
            for (int j = 0; j < n - i - 1; j++) {
                // 如果前一个元素大于后一个元素，则交换它们
                if (arr[j] > arr[j + 1]) {
                    // 交换arr[j]和arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    
    // 测试代码
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.println("排序前数组:");
        printArray(arr);
        
        bubbleSort(arr);
        
        System.out.println("排序后数组:");
        printArray(arr);
    }
    
    // 辅助方法：打印数组
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

2.选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

  • 初始状态：无序区为R[1..n]，有序区为空；
  • 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
  • n-1趟结束，数组有序化了。

2.2 动图演示

2.3 代码实现

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        
        // 外层循环控制当前最小元素应放置的位置
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            
            // 内层循环寻找未排序部分的最小值索引
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            
            // 将找到的最小元素与当前位置交换
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

    // 测试代码
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.println("排序前数组:");
        printArray(arr);
        
        selectionSort(arr);
        
        System.out.println("排序后数组:");
        printArray(arr);
    }
    
    // 辅助方法：打印数组
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

3.插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

  • 外层循环逐个选取待插入元素（从第二个元素开始）
  • 内层循环将当前元素与已排序部分比较并移动元素
  • 找到合适位置后插入当前元素

3.2 动图演示

3.2 代码实现

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        
        // 外层循环：从第二个元素开始遍历（索引1）
        for (int i = 1; i < n; i++) {
            int current = arr[i]; // 当前待插入元素
            int j = i - 1;        // 已排序部分的末尾索引
            
            // 内层循环：向前比较并移动元素
            while (j >= 0 && arr[j] > current) {
                arr[j + 1] = arr[j]; // 元素后移
                j--;
            }
            
            arr[j + 1] = current; // 插入到正确位置
        }
    }

    // 测试代码
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.println("排序前数组:");
        printArray(arr);
        
        insertionSort(arr);
        
        System.out.println("排序后数组:");
        printArray(arr);
    }
    
    // 辅助方法：打印数组
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}


4.希尔排序（Shell Sort）

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

4.1 算法描述

  • 希尔排序通过将数组分成多个子序列来进行插入排序
  • 然后逐步减少子序列的间隔，直到间隔为1
  • 最后进行一次标准的插入排序。
  • 关键在于间隔序列的选择，这里通常使用Knuth序列（h = 3*h + 1）或者简单的一半递减

4.2 动图演示

4.3 代码实现

public class ShellSort {
    public static int[] shellSort(int[] arr) {
        int n = arr.length;

        // 初始间隔设为数组长度的一半，逐步缩小间隔
        for (int gap = n / 2; gap > 0; gap = gap / 2) {
            // 从 gap 开始，进行插入排序
            for (int i = gap; i < n; i++) {
                int current = arr[i];
                int j = i;

                // 将当前元素向前移动，直到找到正确的位置
                while (j - gap >= 0 && current < arr[j - gap]) {
                    arr[j] = arr[j - gap];
                    j = j - gap;
                }
                arr[j] = current;
            }
        }
        return arr;
    }
}

对比插入排序：通过分组大幅减少元素移动次数

5.归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

5.1 算法描述

  • 把长度为n的输入序列分成两个长度为n/2的子序列；
  • 对这两个子序列分别采用归并排序；
  • 将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

5.3 代码实现

public class MergeSort {

    // 归并排序主方法（递归）
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length <= 1) return;

        int mid = arr.length / 2;
        int[] left = new int[mid];
        int[] right = new int[arr.length - mid];

        // 拷贝左右子数组
        System.arraycopy(arr, 0, left, 0, mid);
        System.arraycopy(arr, mid, right, 0, arr.length - mid);

        // 递归排序左右子数组
        mergeSort(left);
        mergeSort(right);

        // 合并已排序的两个子数组
        merge(arr, left, right);
    }

    // 合并两个有序数组的方法
    private static void merge(int[] arr, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;

        // 将左右数组的元素按顺序合并到原数组中
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }

        // 处理剩余元素
        while (i < left.length) {
            arr[k++] = left[i++];
        }

        while (j < right.length) {
            arr[k++] = right[j++];
        }
    }

6.快排算法（Quick Sort）

6.1 算法描述

  1. 先取出数列中的第⼀个数作为基准数
  2. 将数列中⽐基准数⼤的数全部放在它的右边，⽐基准数⼩的数全部放在它的左边
  3. 然后在对左右两部分重复第⼆步，直到各区间只有⼀个数

6.2 动图演示

6.3 代码实现

public class QuickSort {

    // 快速排序的入口方法
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    // 递归实现快速排序
    private static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 找到分区点
            int partitionIndex = partition(arr, low, high);
            // 递归排序左半部分
            quickSort(arr, low, partitionIndex - 1);
            // 递归排序右半部分
            quickSort(arr, partitionIndex + 1, high);
        }
    }

    // 分区函数
    private static int partition(int[] arr, int low, int high) {
        // 选择基准元素（这里选择最后一个元素作为基准）
        int pivot = arr[high];
        // i是较小元素的索引
        int i = low; 

        for (int j = low; j < high; j++) {
            // 如果当前元素小于或等于基准元素
            if (arr[j] <= pivot) {
                // 交换arr[i]和arr[j]
                swap(arr, i, j);
                i++;
            }
        }

        // 将基准元素放到正确的位置
        swap(arr, i, high);

        // 返回分区点的索引
        return i;
    }

    // 交换数组中两个元素的位置
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 测试代码
    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 3,5,2};
        System.out.println("排序前的数组:");
        printArray(arr);

        quickSort(arr);

        System.out.println("排序后的数组:");
        printArray(arr);
    }

    // 打印数组
    private static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

经典排序算法复习
BlackCarDriver的博客
03-08 536
十大经典排序算法 备忘录 本博客用于快速复习几种简单排序算法。这些算法虽然经典，但是都很简单，只要明白其思想和原理，都能很快写出来。关键是要把握好一些细节之处，例如循环边界等。 代码 #pragma warning(disable : 4996) #include<iostream> #include<vector> #include<algorithm> #...
十大经典排序算法
qq_40896594的博客
05-30 3640
十种常见的排序算法可分为以下两大类： 比较类排序：通过比较来决定元素间的相对位置，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对位置，它可以突破基于比较排序的时间下限，以线性时间运行，因此也称为线性时间非比较类排序。 时间复杂度： 从序列的初始状态到经过排序算法的变换移位等操作变到最终排序好的结果状态的过程所花费的时间度量。
【数据结构】十大经典排序算法总结与分析
2301_80191662的博客
09-13 2724
十大经典排序算法总结与分析，以及一些排序中相关内容的补充
十大经典排序算法总结整理
ytusdc的博客
10-12 6873
参考文章： 十大经典排序算法最强总结：https://www.cnblogs.com/guoyaohua/p/8600214.html 排序算法总结:https://www.runoob.com/w3cnote/sort-algorithm-summary.html 术语说明 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数...
深入浅出经典排序算法
改变世界的梦想从未改变
12-30 5393
1. 冒泡排序 2. 插入排序 3. 快速排序 4. 希尔排序 5. 归并排序 6. 桶排序
十大经典排序算法最强总结
张巧龙的博客
09-07 3841
点击上方“我要学编程”，选择“置顶/星标公众号”福利干货，第一时间送达！排序算法属于经典基础算法基本功，笔试面试基本都会涉及和考察的，有原题也有变化，不过基础的几大排序算法还是得尽可能熟...
总结经典排序算法
zou_albert的博客
06-19 698
0. 算法概述 0.1算法分类 十种常见排序算法可以分为两大类： 比较排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2算法复杂度 0.3相关的概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间
经典排序算法分析及实现
ZWE7616175的博客
03-05 2498
一、排序概念 1. 排序：将一组杂乱无章的数据按照一定的规律组织起来，就称为排序。 2. 数据表：待排序的数据元素的有限集合。 3. 排序码：通常数据元素有多个属性域，其中有一个属性域可以用来区分元素，作为排序依据，该域即为排序码。 * 若在数据表中各个元素的排序码各不相同，这种排序码称为主排序码。 * 按照主排序码进行排序，排序的结果是唯一的。 * 按照次排序码进行排序，排序结果不唯一。 ...
【排序算法】八大经典排序算法详解
qq_40205510的博客
05-01 3062
理解这些基础排序算法不仅是掌握数据结构的关键，更是优化实际工程问题的基础。建议读者通过可视化工具（如Visualgo）观察算法的执行过程，并尝试自己实现不同版本的排序算法来加深理解。
C语言中三大经典的排序算法
热门推荐
曹绍坚(嵌入式学生)
04-08 1万+
掌握好常用的排序算法，在实际的项目开发中可以节省很多的时间。每一种排序算法在执行的效率上是存在差别的，这些微小的时间差，也许在平常的联系当中感觉不到，但是涉及到数据量比较大或者是在资源比较紧张的系统中就显得尤其的重要，比如嵌入式系统。下面简要介绍三种常用的排序算法以及他们的执行效率的比较。 冒泡排序： 思路：将相邻的两个数比较，将较小的数调到前头；有n个数就要进行n-1趟比较，第一次比较中要进
C++(归并排序算法)
最新发布
weixin_46669997的博客
06-24 243
归并排序算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值