八大排序算法

已于 2023-03-21 20:45:43 修改
阅读量73 收藏
点赞数
文章标签： 排序算法 算法 数据结构
于 2023-03-21 17:14:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HFJsjsn/article/details/129692748
版权

排序算法

注:本文章是看韩顺平老师将的数据结构java，以及在网上查找的其他文章，以及我的理解总结的；有说的不明白的地方，可以在评论区告诉我，我会更新和修改。

排序算法的分类

冒泡排序

基本介绍

思路

代码实现

public class BubblingSort {
    public static void main(String[] args) {
        //定义一个数组
        int[] Arr = {-1,-9,6,58,99,55};
        int temp;
        //冒泡排序
        for(int i=0;i<Arr.length-1;i++) {
            
​
            for(int j = 0;j<Arr.length-i-1;j++) {
                if(Arr[j]>Arr[j+1]) {
                    temp = Arr[j];
                    Arr[j] = Arr[j+1];
                    Arr[j+1] = temp;
                }
                
            }
            System.out.printf("第%d次后",i);
            System.out.println(Arrays.toString(Arr));
        }
    }
​
}

代码优化

public class BubblingSort {
    public static void main(String[] args) {
        
​
        //测试一手，输入800000个数据
        int[] Arr = new int[80000];
        for(int i=0;i<80000;i++) {
            Arr[i] = (int)(Math.random()*80000);
        }
        //定义时间变量
        Date date1 = new Date();
        SimpleDateFormat s1 = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String Date_1= s1.format(date1);
        System.out.println("排序前的时间："+Date_1);
        BubblingS(Arr);
        Date date2 = new Date();
        
        String Date_2= s1.format(date2);
        System.out.println("排序后的时间："+Date_2);
    
    }
    //封装成方法
​
public static void BubblingS(int[] Arr) {
    int temp;
    //冒泡排序
    boolean loop = false;//定义监管loop，如果在一次排序中如果不交换，则表示数组排序已经完成，便可退出
    for(int i=0;i<Arr.length-1;i++) {
        
​
        for(int j = 0;j<Arr.length-i-1;j++) {
            if(Arr[j]>Arr[j+1]) {
                loop = true;
                temp = Arr[j];
                Arr[j] = Arr[j+1];
                Arr[j+1] = temp;
            }
            
        }
        if(!loop) {//在一次排序中，一次也没交换
            break;
            
        }else {
            loop=false;//如果交换了，重新把loop改为false;
        }
        //System.out.printf("第%d次后",i);
        //System.out.println(Arrays.toString(Arr));
    }
​
}
                
​
}

测试80000个数据排序时间

选择排序

基本介绍

给出一个数组Arr，首先从【0——n-1】中找出一个最小值，并与第一个数（Arr[0]）交换 ,然后再从【1——n-1】中找出一个最小值，并与第二个数（Arr[1]）交换…………，依次进行，直至最后，但最后一个不用找 换，所以值循环n-1次

思路

代码实现

//包装成方法
    public static void ChoiceS_(int[] Arr) {
        for (int j = 0; j < Arr.length - 1; j++) {
            int mintemp = Arr[j];
            int index = j;
            for (int i = j; i < Arr.length; i++) {
                if (Arr[i] < mintemp) {
                    mintemp = Arr[i];
                    index = i;
                }


        }
        Arr[index] = Arr[j];
        Arr[j] = mintemp;
​
        //System.out.println("第" + (j + 1) + "次排序" + Arrays.toString(Arr));
    }
}

测试80000个数据的时间

比冒泡吊多了

插入排序

基本介绍

把数组Arr看成一个顺序序列，一个乱序序列，顺序序列一开始就一个为数组开头，乱序是剩下的。每次插入，取乱序序列第一个值，按照顺序查入顺序数列（后移吊）

思路

代码实现

//包装成方法
    public static void ChoiceS_(int[] Arr) {
        for (int j = 0; j < Arr.length - 1; j++) {
            int mintemp = Arr[j];
            int index = j;
            for (int i = j; i < Arr.length; i++) {
                if (Arr[i] < mintemp) {
                    mintemp = Arr[i];
                    index = i;
                }


        }
        Arr[index] = Arr[j];
        Arr[j] = mintemp;
​
        //System.out.println("第" + (j + 1) + "次排序" + Arrays.toString(Arr));
    }
}

测试80000个数据

希尔排序

基本介绍

把一个数组根据下标分为int gap =（length/2）组，分别对每组进行排序，排序完在接着分为gap/2组，在分别对每组进行排序，…………直到gap等于1，排序结束。

图解思路

代码实现

第一中是交换法实现，就是每两个数进行比较，如果条件符合就交换。这种方法速度慢。

第二钟是移动法，类似于插入排序，速度块，比较吊。

package com.hanfei.sort;
​
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
​
public class ShellSort_1 {
​
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 创建测试数组
        // 测试一手，输入800000个数据
        int[] Arr = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            Arr[i] = (int) (Math.random() * 800000);
        }
        // 定义时间变量
        Date date1 = new Date();
        SimpleDateFormat s1 = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String Date_1 = s1.format(date1);
        System.out.println("排序前的时间：" + Date_1);
        ShellS_2(Arr);
        Date date2 = new Date();
    
        String Date_2 = s1.format(date2);
        System.out.println("排序后的时间：" + Date_2);
    
    }
    
    // 交换法的希尔排序
    public static void ShellS(int[] Arr) {
        // 定义辅助变量
        int temp = 0;
        int count = 0;
        for (int gap = Arr.length / 2; gap > 0; gap /= 2) {
    
            for (int i = gap; i < Arr.length; i++) {
    
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (Arr[j] > Arr[j + gap]) {
                        temp = Arr[j + gap];
                        Arr[j + gap] = Arr[j];
                        Arr[j] = temp;
                    }
                }
            }
            count++;
            System.out.println("第" + count + "次" + Arrays.toString(Arr));
        }
    
    }
    // 移位法的查入排序
    
    public static void ShellS_2(int[] Arr) {
        int count = 0;
    
        for (int gap = Arr.length / 2; gap > 0; gap /= 2) {
    
            for (int i = gap; i < Arr.length; i++) {
                int temp = Arr[i];
                int index = i - gap;
                if (Arr[i] < Arr[index]) {
                    while (index >= 0 && temp < Arr[index]) {
                        Arr[index + gap] = Arr[index];
                        index -= gap;
                    }
                    Arr[index + gap] = temp;
                }
            }
            count++;
            //System.out.println("第" + count + "次" + Arrays.toString(Arr));
        }
    }
​
}
​
​

移动法比较800000个数据，仅仅只需两秒。80000只需不到一秒

快速排序

基本介绍

以数组{6,3,7,1,9,4,8,5,2,10}为例。 1.为了便于理解，就以6作为节点，开始排序时low等于6，high等于10 在这里插入图片描述 2.从由右往左找比节点6小的数就是2，从左往右找比节点6大的数就是7，把这两个数交换（这样查找的目的是为了将大的数放后面，较小的数放前面） 在这里插入图片描述 交换后： 在这里插入图片描述 3.交换后，high接着往左找比节点6小的数，同时low接着往右找比6大的数，分别是5和9，交换low和high 在这里插入图片描述 交换后： 在这里插入图片描述 4.接着相同操作，high往左找到比6小的数4，low往右找大于节点6的数时，low与high相遇，那么本轮查找就结束。接着节点6与low和high的相遇点4交换。这样比6小的数都在其前面，比6da的数都在其后面。 在这里插入图片描述 交换后： 在这里插入图片描述 5.一轮操作结束后，原数组被节点6“一分为二”，分别是比6都小的4，3，2，1，5和比6都大的8，9，7，10两个数组。接着就将这两个数组重复上面的操作，操作完成后理论上是数组被“一分为四”,四个数组再进行上面的操作如此循环

注意：上面讲的是以左端（6）为中轴，我写的代码是以右端（10）为中轴写的；

代码实现

package com.hanfei.sort;
​
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
​
public class ShellSort_1 {
​
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 创建测试数组
        // 测试一手，输入800000个数据
        int[] Arr = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            Arr[i] = (int) (Math.random() * 800000);
        }
        // 定义时间变量
        Date date1 = new Date();
        SimpleDateFormat s1 = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String Date_1 = s1.format(date1);
        System.out.println("排序前的时间：" + Date_1);
        ShellS_2(Arr);
        Date date2 = new Date();
    
        String Date_2 = s1.format(date2);
        System.out.println("排序后的时间：" + Date_2);
    
    }
    
    // 交换法的希尔排序
    public static void ShellS(int[] Arr) {
        // 定义辅助变量
        int temp = 0;
        int count = 0;
        for (int gap = Arr.length / 2; gap > 0; gap /= 2) {
    
            for (int i = gap; i < Arr.length; i++) {
    
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (Arr[j] > Arr[j + gap]) {
                        temp = Arr[j + gap];
                        Arr[j + gap] = Arr[j];
                        Arr[j] = temp;
                    }
                }
            }
            count++;
            System.out.println("第" + count + "次" + Arrays.toString(Arr));
        }
    
    }
    // 移位法的查入排序
    
    public static void ShellS_2(int[] Arr) {
        int count = 0;
    
        for (int gap = Arr.length / 2; gap > 0; gap /= 2) {
    
            for (int i = gap; i < Arr.length; i++) {
                int temp = Arr[i];
                int index = i - gap;
                if (Arr[i] < Arr[index]) {
                    while (index >= 0 && temp < Arr[index]) {
                        Arr[index + gap] = Arr[index];
                        index -= gap;
                    }
                    Arr[index + gap] = temp;
                }
            }
            count++;
            //System.out.println("第" + count + "次" + Arrays.toString(Arr));
        }
    }
​
}

注意：当选最后一个为中轴数的时候，需要先从左边找比他大的数，因为最后左边找到的最后一个数要与中轴值交换

归并排序

基本介绍

归并排序主要思想是分而治之，先将数组逐步分开，在排序合并（很吊）

图解思路

代码实现

package com.hanfei.sort;
​
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
​
public class MergeSort {
    public static void main(String[] args) {
        int[] Arr = new int[8000000];
        int[] temp = new int[Arr.length];
        // 测试一手，输入800000个数据
        
​
        for (int i = 0; i < 8000000; i++) {
            Arr[i] = (int) (Math.random() * 800000);
        }
        // 定义时间变量
        Date date1 = new Date();
        SimpleDateFormat s1 = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String Date_1 = s1.format(date1);
        System.out.println("排序前的时间：" + Date_1);
        MerGe_1(Arr, 0, Arr.length-1, temp);
        Date date2 = new Date();
    
        String Date_2 = s1.format(date2);
        System.out.println("排序后的时间：" + Date_2);
    
    }
    
    // 分和和
    //left代表数组最左边下边，初始0
    //right代表数组最右边下标，初始Arr.length-1
    //Arr,排序数组
    //temp 辅助数组
    public static void MerGe_1(int[] Arr, int left, int right, int[] temp) {
    
        if (left < right) {
            int mid = (left + right) / 2;
            // 向左边分
            MerGe_1(Arr, left, mid, temp);
            // 向右分
            MerGe_1(Arr, mid + 1, right, temp);
            Merge_(Arr, left, mid, right, temp);
        }
    
    }
    
    // 写和并的过程
    public static void Merge_(int[] Arr, int left, int mid, int right, int[] temp) {
    
        int l = left;
        int r = mid + 1;
        int t = 0;// temp数组辅助变量
    
        // 比较两个有序数组按顺序存入temp中
        while (l <= mid && r <= right) {
            // 如果左测数组值比右边小就存左边的，否则存右边的
            if (Arr[l] <= Arr[r]) {
                temp[t] = Arr[l];
                t += 1;
                l += 1;
            } else {
                temp[t] = Arr[r];
                t += 1;
                r += 1;
            }
        }
        // 将剩余值存入temp
        // 先判断左边
        while (l <= mid) {
            temp[t] = Arr[l];
            t += 1;
            l += 1;
        }
        // 再判断右边
        while (r <= right) {
            temp[t] = Arr[r];
            t += 1;
            r += 1;
        }
    
        // 最后将temp数组的值赋值给Arr
        t = 0;// 将t指向第一个
        int tempLeft = left;
        while (tempLeft <= right) {
            Arr[tempLeft] = temp[t];
            tempLeft++;
            t++;
        }
    }
​
}

基数排序

基本介绍

将数组中的数，按照不同位数的大小存入对应的桶中（二维数组），先按个位-十位-……等等依次，每次存储一次后，都要按桶中的顺序在输回原数组。（说的不好！下次一定）。

图解思路

 

代码实现

package com.hanfei.sort;
​
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
​
public class RedixSort {
    public static void main(String[] args) {
        // 测试一手，输入800000个数据
        int[] Arr = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            Arr[i] = (int) (Math.random() * 800000);
        }
        // 定义时间变量
        Date date1 = new Date();
        SimpleDateFormat s1 = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String Date_1 = s1.format(date1);
        System.out.println("排序前的时间：" + Date_1);
        Redix_1(Arr);
        Date date2 = new Date();
​
        String Date_2 = s1.format(date2);
        System.out.println("排序后的时间：" + Date_2);
    
    }
    
    // 排序方法
    public static void Redix_1(int[] Arr) {
    
        int max = Arr[0];
        // 去数组中最大的数
        for (int i = 0; i < Arr.length; i++) {
            if (Arr[i] > max) {
                max = Arr[i];
            }
        }
        int maxlength = (max + "").length();
        // 创建二维数组，做桶元素,定义十个桶存储各个位数的数
        // 10代表0-9十个数
        // 不知道一个桶存放几个元素，所以按照最环情况处理
        int[][] bucket = new int[10][Arr.length];
    
        // 定义一维数组，当作每个桶的指针
        int[] bucketcount = new int[10];
    
        for (int r = 0, n = 1; r < maxlength; r++, n *= 10) {
    
            // 第一次存储
            // 遍历所给数组
            for (int i = 0; i < Arr.length; i++) {
                // 判断个位数是什么
                int weishuDate = Arr[i] / n % 10;
    
                bucket[weishuDate][bucketcount[weishuDate]] = Arr[i];
                // 该位置的指针自增
                bucketcount[weishuDate]++;
    
            }
            int index = 0;
            // 从桶中依次取出数据
            for (int j = 0; j < 10; j++) {
                if (bucketcount[j] != 0) {
                    for (int l = 0; l < bucketcount[j]; l++) {
                        Arr[index] = bucket[j][l];
                        index++;
                    }
    
                }
                // 靠这条语句控制数组数据
                bucketcount[j] = 0;
            }
    
        }
    }
​
}

排序算法的比较

堆排序

基本介绍

代码实现

package com.hanfei.sort;
​
import java.util.Arrays;
​
import org.omg.PortableServer.ID_ASSIGNMENT_POLICY_ID;
​
public class HeapSort {
    public static void main(String[] args) {
        int[] Arr = {20000,3,323,-2,56,-56};
        for(int i = Arr.length/2-1;i<0;i--) {
            adjustHeap(Arr, i, Arr.length);
        }
        for (int j = Arr.length-1; j > 0; j--) {
            int temp = Arr[j];
            Arr[j] = Arr[0];
            Arr[0] = temp;
            /*为什么从0开始？
                因为在第一次构建大顶堆后让堆顶元素和末尾元素进行交换
                而对于其他的非叶子结点所对应的子树都是大顶堆就无需调整，
                只需要堆顶元素(下标为0的非叶子结点)的子树调整成大顶堆
            */
            adjustHeap(Arr,0,j);
​
        }
        System.out.println(Arrays.toString(Arr));
    
    }
​
//将完全二叉树转化为大堆顶
    /**
     * 
     * @param Arr 要转化的数组
     * @param i   从哪个结点开始转化
     * @param length 转化数组的长度
     */
    public static void adjustHeap(int[] Arr,int i,int length) {
        
​
        /*
         * 取出当前叶子结点的值
         */
        int temp = Arr[i];
        for(int k = i*2+1;k<length;k = i*2+2) {
            if(k+1<length&&Arr[k]<Arr[k+1]) {//如果右结点大于左节点
                k++;//k指向右节点
            }
            if(temp<Arr[k]) {
                Arr[i] = Arr[k];
                i = k;
            }else {
                break;
            }
            
            Arr[k]=temp;
        }
    }
​
}

HFJsjsn
关注
八大排序算法详解（通俗易懂）
weixin_61661271的博客
08-03 1万+
排序算法很重要，本篇重点讲解它，如果本篇博客对你有所帮助，请给博主一个三连哦！
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
【C语言】八大排序算法
weixin_63449996的博客
09-30 1万+
本文详细介绍了数据结构的排序算法，结合动图，基本思想，解析，代码，你也可以手撕算法。
常见八大排序算法
crazy_xieyi的博客
10-30 675
八大常见排序算法： 一、直接插入排序 二、希尔排序 三、选择排序 四、堆排序 五、冒泡排序 六、快速排序 1.递归实现 2.非递归实现 七、归并排序 1.递归实现 2.非递归实现 八、计数排序 目前上述几种排序算法，只有直接插入排序、冒泡排序、归并排序和计数排序是稳定的。
【数据结构】 常见的八大排序算法
阿润菜菜的博客
12-25 1万+
​排序有内部排序和外部排序，这里八大排序就是内部排序，指直接插入，希尔，选择，堆排，冒泡，快排，归并，计数。 附有动图解释和思维导图汇总
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
Xpccccc的博客
10-13 5725
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
常见的八大排序算法
学Java，找哪吒
02-17 1万+
目录一、算法思维导图二、算法分类三、冒泡排序1、基本思想2、动态效果图3、代码实现4、速度测试四、选择排序1、基本思想2、动态效果图3、代码实现4、速度测试五、插入排序1、基本思想2、动态效果图3、代码实现4、速度测试六、希尔排序1、基本思想2、效果图3、代码实例七、快速排序1、基本思想2、效果图3、算法描述4、代码实例5、速度测试八、归并排序1、基本思想2、效果图3、代码实现4、速度测试九、基数排序1、基本思想2、动态效果图3、代码实例4、速度测试 一、算法思维导图 二、算法分类 算法的时间复杂度和空
java八大排序算法详解
qq_57420582的博客
06-29 770
java八大排序算法详解
【数据结构】八大排序算法
m0_63198468的博客
06-12 1227
本文重点讲述了八种排序方法：冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序，以及计数排序。里面包含了每种排序方法的思路，以及相对清晰的图片加动图，希望可以帮助大家理解八大排序算法。
Python实现八大排序算法
01-20
如何用Python实现八大排序算法 1、插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为 O(n^2)。是稳定...
python八大排序算法速度实例对比
09-21
### Python八大排序算法速度实例对比 #### 排序算法概览 本文主要通过实例的方式对Python中的八大排序算法进行了速度对比。这些算法分别是：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、...
八大排序详解
weixin_73077334的博客
09-29 857
八大排序详解
Java：插入排序
xiaochuan_bsj的博客
09-28 663
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；直接插入排序是稳定的，由上面图片能看到它是具有稳定性的，但如果是代码部分的 arr[j] > tmp 改为：arr[j] >= tmp，以上面的2a和2b为例，它们的顺序就会发生变化。所谓的排序，就是使一串记录，按照某个或某些关键字的大小，递增或递减的排列起来的操作。
java 选择排序
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
09-25 298
在每一轮中，内层循环负责在未排序的元素中找出最小元素的位置。找到后，通过一次交换，将该最小元素放到已排序序列的末尾（即当前外层循环的位置）。这样，随着外层循环的进行，已排序序列逐渐增长，直到整个数组排序完成。它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。选择排序的平均时间复杂度和最坏时间复杂度都是 O(n^2)，其中 n 是数组的长度。因此，它也不是处理大数据集时最高效的排序算法之一。
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 374
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
【数据结构初阶】排序算法(上)插入排序与选择排序
fhvyxyci的博客
09-25 1485
1.排序概念及运用 1. 1 概念 1. 2 运用 1.3 常见排序算法 2. 插入排序 2. 1 直接插入排序 2. 2 希尔排序 2. 2. 1 希尔排序的时间复杂度 3. 选择排序 3. 1 直接选择排序 3. 2 堆排序 3. 3 Top-K问题
二叉树最小深度
2301_80161204的博客
09-27 466
25[0, 105]
数据结构八大排序算法详解
"排序算法总结，包括数据结构中常见的八大排序算法：直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。此外，还提及了外部排序的基本概念。" 1. 直接插入排序：这种排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值