【收藏】排序算法总结

最新推荐文章于 2024-07-18 23:12:01 发布
最新推荐文章于 2024-07-18 23:12:01 发布
阅读量201 收藏
点赞数
文章标签： 算法 排序算法 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30836691/article/details/109851576
版权
本文详细介绍了几种常见的排序算法，包括冒泡排序、选择排序、插入排序等简单排序算法，以及希尔排序、归并排序、快速排序等高级排序算法。不仅阐述了每种排序算法的工作原理，还提供了具体的代码实现，并对每种算法的时间复杂度、空间复杂度及稳定性进行了深入分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

排序算法总结

一、排序算法总结

二、简单排序

2.1 冒泡排序

  1. 排序原理：

    1）比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。

    2）对每一对相邻元素做同样的工作，从开始第一对元素到末尾的最后一对元素。最终最后位置的元素就是最大值。

  2. 代码实现

    public class Bubble{
    public static void sort(Comparable[] a){
        for(int i = a.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(greater[a[j], a[j + 1]]){
                    swap(a, j, j + 1);
                }
            }
        }
    }
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    private static void swap(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

  3. 复杂度分析

    • 时间复杂度

      元素比较次数：n*(n-1)/2，元素交换次数：n*(n-1)/2，总执行次数：n2-n，

      时间复杂度：O(n2)

    • 空间复杂度

      O(1)

    • 稳定性

      稳定，因为相等的时候不交换位置。

2.2 选择排序

  1. 排序原理

    1）每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值为最小值，记录该索引值

    2）交换第一个索引值和记录的索引值

  2. 代码实现

    public class Selection{
    public static void sort(Comparable[] a){
        for(int i = 0; i < a.length - 1; i++){
            int minIndex = i;
            for(int j = i + 1; j < a.length; j++){
                if(greater(a[minIndex], a[j])){
                    minIndex = j;
                }
            }
            swap(a, i, minIndex);
        }
    }
    public static void greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    public static void swap(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

  3. 复杂度分析

    • 时间复杂度

      数据比较次数：n*(n-1)/2，数据交换次数：n-1，时间复杂度：O(n2)

    • 空间复杂度

      O(1)

    • 稳定性

      不稳定，排序过程中有当前选则的最小元素进行交换时，发生原来相等元素的位置顺序改变。

2.3 插入排序

  1. 排序原理

    1）把所有的元素分为两组，已经排序的和未排序的

    2）找到未排序的组中的第一个元素，向已经排序的组中进行插入

    3）倒叙遍历已经排序的元素，依次和待插入元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位。

  2. 代码实现

    public class Insertion{
    public static void sort(Comparable[] a){
        for(int i = 1; i < a.length; i++){
            for(int j = i; j > 0; j--){
                if(greater(a[j - 1], a[j])){
                    swap(a, j - 1, j);
                }else{
                    break;
                }
            }
        }
    }
    public static void greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    public static void swap(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

  3. 复杂度分析

    • 时间复杂度

      数据比较次数：n*(n-1)/2，数据交换次数：n*(n-1)/2，总执行次数：n2-n，

      时间复杂度：O（n2)

    • 空间复杂度

      O(1)

    • 稳定性

      稳定，相等时，不改变元素位置顺序。

三、高级排序

3.1 希尔排序

  1. 排序原理

    1）选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组

    2）对分好组的每一组数据完成插入排序

    3）减小增长量，最小减为1，重复第二部操作

  2. 代码实现

    public class Shell{
    public static void sort(Comparable[] a){
        int N = a.length;
        int h = 1;
        while(h < N / 2){
            h = h * 2 + 1;
        }
        while(h >= 1){
            for(int i = h; i < N; i++){
                for(int j = i; j >= h; j -= h){
                    if(greater(a[j - h], a[j])){
                        swap(a, j, j - h);
                    }else{
                        break;
                    }
                }
            }
        }
    }
    public static void greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    public static void swap(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

//从本地读取文件测试希尔排序
public static void main(String[] args)throws Exception{
    ArrayList<Integer> list = new ArrayList<>();
    //读取本地文件
    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("rest.txt")));
    String line = null;
    while((line = reader.readLine()) != null){
        //把每一个数字存入到集合中
        list.add(Integer.valueOf(line));
    }
    reader.close();
    //把集合转换成数组
    Integer[] arr = new Integer[list.size()];
    list.toArray(arr);
    
    long start = System.currentTimeMillis();
    Shell.sort(arr);
    long end = System.currentTimeMillis();
    System.out.println("使用希尔排序耗时："+(end-start)); 
}

  3. 复杂度分析

    • 时间复杂度

      对于不同的递增序列可能导致不同的事前估计值，应该采用事后分析法。

    • 空间复杂度

      O(1)

    • 稳定性

      不稳定，多次插入排序有可能移动原来相等元素的位置顺序。

3.2归并排序

  1. 排序原理——分治思想

    1）将数据拆分成两组，再递归的对子组继续拆分，直到每个子组中的元素个数为1；

    2）将相邻的子组合并成一个更大的有序子组；

    3）重复步骤2），直到将整组数组排好序。

  2. 代码实现

    public class Merge {
    private static Comparable[] assist;     //辅助数组
    public static void sort(Comparable[] a){
        assist = new Comparable[a.length];
        int low = 0;
        int high = a.length - 1;
        sort(a, low, high);
    }
    private static void sort(Comparable[] a, int low, int high) {
        if(low >= high){
            return;
        }
        int mid = (low + high) / 2;
        sort(a, low, mid);
        sort(a, mid + 1, high);
        merge(a, low, mid, high);
    }
    private static void merge(Comparable[] a, int low, int mid, int high) {
        int i = low;        //assist数组移动指针
        int left = low;       //左半部分指针，初始指向首元素
        int right = mid + 1;    //右半部分指针，初始指向mid+1位置元素
        while (left <= mid && right <= high){
            if(less(a[left], a[right])){
                assist[i++] = a[left++];
            }else {
                assist[i++] = a[right++];
            }
        }
        //左边部分未遍历完
        while (left <= mid){
            assist[i++] = a[left++];
        }
        //右边部分未遍历完
        while (right <= high){
            assist[i++] = a[right++];
        }
        //将排好序的辅助数组复制到目标数组中
        System.arraycopy(assist, 0, a, 0, high);
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
}

  3. 复杂度分析

    • 时间复杂度

      采用了分治策略，递归的拆分子组，时间复杂度为O(nlogn），证明见数据结构与算法一书。

    • 空间复杂度

      O(n)，因为借助了辅助数组，典型的空间换时间。

    • 稳定性

      稳定，只有不等（本例为小于）时才会交换位置，相等元素不改变位置顺序。

3.3 快速排序

  1. 排序原理

    1）首先设定一个分界值，通过该分界值将数组划分为左右两部分；

    2）将大于或等于该分界值的数据放到数组右边，小于的放到数组左边；

    3）递归对左右两边进行排序，重新选取分界值，重新划分；

    4）重复上述处理，直到整体有序。

    划分原理：

    1）确定一个基准值，用两个指针分别指向数组的首尾；

    2）分别从首尾开始探寻，从首部开始的，寻找比基准值大的，从尾部开始的，寻找比基准值小的，一旦找到立即停止探寻；——保证数组左边小于基准值，右边大于基准值

    3）交换两指针元素；

    4）重复2），3）步骤，直到左指针大于右指针。

  2. 代码实现

    public class Quick {
    public static void sort(Comparable[] a){
        int low = 0;
        int high = a.length - 1;
        sort(a, low, high);
    }
    private static void sort(Comparable[] a, int low, int high) {
        if(low >= high){
            return;
        }
        //对当前数组进行划分
        int partition = partition(a, low, high);
        sort(a, low, partition);
        sort(a, partition + 1, high);
    }
    private static int partition(Comparable[] a, int low, int high) {
        Comparable baseNum = a[low];        //默认把最左边元素当做基准值
        int left = low;
        int right = high + 1;
        //划分
        while (true){
            //先从右往左扫描，找到一个比基准值小的元素
            while (less(baseNum, a[--right])) {
                if(right == low){
                    break;  //当扫描到最左边时，停止扫描
                }
            }
            //从左往右扫描，找到一个比基准值大的元素
            while (less(a[++left], baseNum)){
                if(left == high){
                    break;
                }
            }
            if(left >= right){
                break;          //已经扫描完所有元素
            }else{
                swap(a, left, right);
            }
        }
        swap(a, low, right);
        return right;
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
	public static void swap(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

  3. 复杂度分析

    • 时间复杂度

      快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n)，但整个快速排序的时间复杂度和切分的次数相关。

      最优情况下快速排序的时间复杂度为O(nlogn)；最坏情况下，快速排序的时间复杂度为O(n2)；平均时间复杂度为O(nlogn)。

    • 空间复杂度

      O(n)或者O(logn)，因为递归造成栈空间的开销，最优（递归深度）为logn，即空间复杂度为：O(logn)，最坏情况下需要进行n-1次递归调用，所以为O(n)。

    • 稳定性

      不稳定，基准值的比较机制会移动相等元素的位置顺序。

冒泡排序、选择排序、插入排序java代码实现
pjsmm的博客
05-09 198
1.冒泡排序 这种排序方式是最简单的，4, 3, 6, 7来当作一个例子（从小到大排序），每一次进行排序先选择第一个4与后面的3进行比较然后4比3大交换位置，4与6比较6大不变，6与7比较7大不变，这样一趟之后最大的值就到了最后的位置。依次进行一共是n-1次就完成了排序。 public class Test15 { public static void main(String[] args) { int arr[] = { 4, 3, 6, 7, 2, 9, -4, -90, 67, 88, 4 };
【C++】c++排序算法入门之计数排序
明月别枝惊鹊的博客
02-19 3421
计数排序（Counting Sort）算法。这是一种非基于比较的排序算法，特别适用于对整数进行排序，尤其是当输入数据范围不是很大时，其性能表现非常出色。
java冒泡排序代码
08-06
java冒泡排序代码，亲测能用，控制台输入数据，自动排序
冒泡排序、选择排序、插入排序 原理及Java代码实现
shijialeya
05-30 5257
1、冒泡排序 冒泡排序（Bubble Sort）： 是一种计算机科学领域的较简单的排序算法。 冒泡排序算法的原理如下： 1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2）对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 3）针对所有的元素重复以上的步骤，除了最后一个。 4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 冒泡升序排序步骤如下图： Java代码实现冒泡排序： import java.util.Arrays
用JAVA代码实现冒泡排序
Sunny0703的专栏
07-28 835
1算法原理编辑 冒泡排序算法的运作如下：（从后往前） 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
C语言实现快速排序算法
热门推荐
C语言C++学习俱乐部：765860056
12-17 3万+
序 愿天上的每一个流星，都为你而闪耀天际。 嗨，这里是狐狸~~ 今天是
【C语言】插入排序（经典算法，建议收藏！！！）
2301_81193162的博客
06-10 6142
插入算法作为几大经典的排序算法之一。插入算法的基本原理就是在一串乱序的数字中，首先认为第一个数是有序的，然后从第二个数开始比较，每次比较都与前面排好序的部分由后往前进行比较，依此类推即可完成排序。
Java实现基数排序算法详解及优化
最新发布
qq_40254606的博客
07-18 1027
基数排序（Radix Sort）是一种非比较型整数排序算法，通过将整数按位进行排序来实现。它具有稳定、高效的特点，特别适用于大规模数据的排序。本文将详细讲解如何使用Java实现基数排序算法，并结合图解和实例代码，帮助您全面理解这一高级排序算法。同时，我们还将进行时间复杂度分析，并探讨基数排序的优化方法，以进一步提高其性能。基数排序通过按位排序，从最低位到最高位（或从最高位到最低位）逐步进行，最终得到有序数组。它通常使用计数排序作为子过程来实现按位排序。为了更清晰地展示基数排序的过程，以下使用一个简单示例并分
JS实现各种排序算法(持续更新)
2401_84152223的博客
04-19 453
今天的文章可谓是积蓄了我这几年来的应聘和面试经历总结出来的经验，干货满满呀！如果你能够一直坚持看到这儿，那么首先我还是十分佩服你的毅力的。所以看完之后，还是多多行动起来吧！可以非常负责地说，如果你能够坚持把我上面列举的内容都一个不拉地看完并且全部消化为自己的知识的话，那么你就至少已经达到了中级开发工程师以上的水平，进入大厂技术这块是基本没有什么问题的了。大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）
Java冒泡排序代码
03-05
package JavaClassTest1; //测试冒泡排序 /********************* * int[] num = {23,45,76,78,98,54,}; 第一次 23 45 76 78 54 98 第二次 23 45 76 54 78 98 第三次 23 45 54 76 78 98 输出 ：23 45 54 76 78 98 当判断为正确时就退出循环 *********************/ public class TestMaoPaoPaiXu { public static void main(String[] args) { //Scanner reader = new Scanner(System.in); // int[] num = {3,4,6,8,9}; int[] num = {23,45,76,78,98,54,}; // for(int a : num) { // System.out.print(a + " "); // } // System.out.println(); boolean flog = true; for(int i = 1;i < num.length&&flog;i++) { //num.length个元素，终须只需循环num.length-1次 flog = false; for(int j = 0;j num[j + 1]) {////注意此处不是i，而是j，如果是i，会提示越界 int s= num[j]; num[j] = num[j + 1]; num[j + 1] = s; flog = true; } } for(int a : num) //注意这个输出for语句放在外层for里面 System.out.print(a + " "); System.out.println(); } } }
冒泡排序java原理_冒泡排序的原理及java代码实现
weixin_39750598的博客
02-18 342
概述冒泡排序是一种简单的排序算法。它重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的开始。简单点说，就是：冒泡排序是將比較大的數字沉在数组的后面(可以理解为下面)，较小的浮在前面(上面)。直观释义图：步骤比较相邻的元素。如果第一个比第二个大，就交换他们两个。对...
冒泡排序、插入排序、选择排序的原理及比较
zhuhai__yizhi的专栏
04-14 778
public class Test { public static void main(String[] args) { int arr[] = {23,34,34,53,67,77,77, 45, 46, 457,657 ,676,8, 876, 3}; bubbleSort(arr); //selectSort(arr); //insertSort(arr); for (
冒泡排序 选择排序 插入排序 java实现
weixin_48680790的博客
01-20 564
1.冒泡排序 原理;每一次排序都将最大/小的元素放在数组的最末尾 public class BubbleSort implements Sort { @Override public void sort(int[] arr) { for (int i =0;i < arr.length-1;i++) { boolean flag = true; for (int j = 0;j < arr
java直接排序算法_经典（java版）排序算法的分析及实现之一直接插入排序
weixin_42465297的博客
02-15 268
预备知识排序算法从功能上是对一个数据元素集合或序列重新排列成一个按数据元素某个相知有序的序列。从内存空间使用简单上看分为内部排序和外部排序。内部排序是数据记录在内存中进行排序，适合不太大的元素序列。而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 排序算法稳定性是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。比如：Ai=A...
java--冒泡排序
dmuhan的博客
07-09 269
冒泡排序法：关键字较小的记录好比气泡逐趟上浮，关键字较大的记录好比石块下沉，每趟有一块最大的石块沉底。 算法本质：（最大值是关键点，肯定放到最后了，如此循环）每次都从第一位向后滚动比较，使最大值沉底，最小值上升一次，最后一位向前推进（即最后一位刚确定的最大值不再参加比较，比较次数减1） 复杂度： 时间复杂度 O(n2) ，空间复杂度O(1) JAVA源代码
冒泡、快速、插入三种排序对应的原理
weixin_44793569的博客
07-21 191
一.冒泡排序 说起冒泡排序，可能每个人都不会陌生，实现思路相当简单明了，就是不停的对数组进行两两比较，将较大（较小）的一项放在前面； 如 var arr = [7, 3, 10, 1, 8, 4, 2, 4, 4, 3] 进行升序排列,排序过程如下 第一次 [3, 7, 1, 8, 4, 2, 4, 4, 3, 10] 第二次 [3, 1, 7, 4, 2, 4, 4, 3, 8, 10] 以此类推 。。。。 结果 [1, 2, 3, 3, 4, 4, 4, 7, 8, 10]； //
java代码实现冒泡排序
weixin_42329970的博客
07-18 211
冒泡排序的的代码实现 冒泡排序 * 5,6,1,4,9,7,3,10 一共需要比较总的元素-1轮 * 以第一个数5与下一个比较，如果比5大则交换，如第一轮比较5比6小，不交换 * 5,6,1,4,9,7,3,10 * 第二次比较 6与1比较，6大于1，交换 * 5,1,6，4,9,7,3,10 * 第三次比较 6与4比较，交换 * 5,1,4,6,9,7,3,10 * 直到比较的第一轮结束后， *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值