经典排序算法总结

已于 2024-08-27 15:47:35 修改
阅读量929 收藏 2
点赞数 3
分类专栏： 数据结构与算法 文章标签： 排序算法 算法 java
于 2023-09-12 16:52:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41805567/article/details/132830837
版权

🍓 简介：java系列技术分享(👉持续更新中…🔥)
🍓 初衷:一起学习、一起进步、坚持不懈
🍓 如果文章内容有误与您的想法不一致,欢迎大家在评论区指正🙏
🍓 希望这篇文章对你有所帮助,欢迎点赞 👍 收藏 ⭐留言 📝

🍓 更多文章请点击
在这里插入图片描述在这里插入图片描述

文章目录

一、 冒泡排序

1.1 排序原理

  1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
  2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
    在这里插入图片描述

1.2 代码实现

注释非常清晰,可以参考理解

public class Bubble {
    /*
       对数组a中的元素进行排序
    */
    public static void sort(Comparable[] a){
        //外层循环控制需要剩余排序的数量
        for(int i=a.length-1;i>0;i--){
            //内层循环进行判断
            for(int j=0;j<i;j++){
                //比较索引j和索引j+1处的值,当前元素大于下一个元素则进行交换
                if (greater(a[j],a[j+1])){
                    //进行交换
                    exch(a,j,j+1);
                }
            }
        }
    }

    /*
        比较v元素是否大于w元素
     */
    private static  boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

1.3 测试

public class BubbleTest {
    public static void main(String[] args) {
        Integer[] arr = {4,5,6,3,2,1};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

在这里插入图片描述

1.4 时间复杂度分析

冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：
元素比较的次数为：

​ (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交换的次数为：

​ (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为：

​ (N2/2-N/2)+(N2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2)

二、 选择排序

2.1 排序原理

​1. 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
​2. 交换第一个索引处和最小值所在的索引处的值
在这里插入图片描述

2.2 代码实现

public class Selection {
    /**
     * 对数组a中的元素进行排序
     */
    public static void sort(Comparable[] a){
        //外层循环中【-2】是因为排序如果只剩最后一个,那么也无需排序
        for(int i=0;i<=a.length-2;i++){
            //定义一个变量，记录最小元素所在的索引，默认为参与选择排序的第一个元素所在的位置
            int minIndex = i;
            //因此默认排序的索引从【i+1】开始
            for(int j=i+1;j<a.length;j++){
                //需要比较最小索引minIndex处的值和j索引处的值；
                if (greater(a[minIndex],a[j])){
                    minIndex=j;
                }
            }
            //交换最小元素所在索引minIndex处的值和索引i处的值
            exch(a,i,minIndex);
        }

    }
    /*
        比较v元素是否大于w元素
     */
    private static  boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

2.3 排序原理

public class SelectionTest {
    public static void main(String[] args) {
        //原始数据
        Integer[] a = {4,6,8,7,9,2,10,1};
        Selection.sort(a);
        System.out.println(Arrays.toString(a));//{1,2,4,5,7,8,9,10}
    }
}

在这里插入图片描述

2.4 时间复杂度分析

选择排序使用了双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据交换次数和数据比较次数：

数据比较次数：
​ (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
数据交换次数：
​ N-1
时间复杂度：N2/2-N/2+（N-1）=N2/2+N/2-1;

根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2)

三、插入排序

3.1 排序原理

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

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

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

在这里插入图片描述
在这里插入图片描述

3.2 代码实现

public class Insertion {
    /*
       对数组a中的元素进行排序
    */
    public static void sort(Comparable[] a){
        //因为0索引处的第一个元素默认已排序,所以需要排序的元素索引从1开始
        for(int i=1;i<a.length;i++){
            for(int j=i;j>0;j--){
                //比较索引j处的值和索引j-1处的值，如果索引j-1处的值比索引j处的值大，则交换数据，如果不大，那么就找到合适的位置了，退出循环即可；
                if (greater(a[j-1],a[j])){
                    exch(a,j-1,j);
                }else{
                    break;
                }
            }

        }
    }

    /*
        比较v元素是否大于w元素
     */
    private static  boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

3.3 测试

public class InsertionTest {
    public static void main(String[] args) {
        Integer[] a = {4,3,2,10,12,1,5,6};
        Insertion.sort(a);
        System.out.println(Arrays.toString(a));//{1,2,3,4,5,6,10,12}

    }
}

在这里插入图片描述

3.4 时间复杂度分析

插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：

​ 比较的次数为：

​ (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

​ 交换的次数为：

​ (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

​ 总执行次数为：

​ (N2/2-N/2)+(N2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2)

四、 希尔排序

希尔排序是插入排序的一种，又称 缩小增量排序 ，是 插入排序 \color{#0AF}{插入排序} 插入排序算法的一种更高效的改进版本

4.1 排序原理

​1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组
​2. 对分好组的每一组数据完成插入排序
​3. 减小增长量，最小减为1，重复第二步操作

在这里插入图片描述

4.2 增长量规则

//循环结束后我们就可以确定h的最大值；
int h=1
while(h<5){
	h=2h+1；
}

h的减小规则为：
	h=h/2

4.3 代码实现

public class Shell {
    /*
       对数组a中的元素进行排序
    */
    public static void sort(Comparable[] a){
        //1.根据数组a的长度，确定增长量h的初始值；
        int h = 1;
        while(h<a.length/2){
            h=2*h+1;
        }
        //2.希尔排序
        while(h>=1){
            //排序
            //2.1.找到待插入的元素
            for (int i=h;i<a.length;i++){
                //2.2把待插入的元素插入到有序数列中
                for (int j=i;j>=h;j-=h){

                    //待插入的元素是a[j],比较a[j]和a[j-h]
                    if (greater(a[j-h],a[j])){
                        //交换元素
                        exch(a,j-h,j);
                    }else{
                        //待插入元素已经找到了合适的位置，结束循环；
                        break;
                    }
                }

            }
            //减小h的值
            h= h/2;
        }

    }

    /*
        比较v元素是否大于w元素
     */
    private static  boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

4.4 测试

public class ShellTest {
    public static void main(String[] args) {
        Integer[] a = {9,1,2,5,7,4,8,6,3,5};
        Shell.sort(a);
        System.out.println(Arrays.toString(a));//{1,2,3,4,5,5,6,7,8,9}
    }
}

在这里插入图片描述

4.5 时间复杂度分析

  • 在希尔排序中，增长量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的
  • 我们可以使用事后分析法对希尔排序和插入排序做性能比较。
  • 通过测试发现，在处理大批量数据时，希尔排序的性能确实高于插入排序

五、 归并排序

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

5.1 排序原理

  1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
  2. 将相邻的两个子组进行合并成一个有序的大组；
  3. 不断的重复步骤2，直到最终只有一个组为止。
    在这里插入图片描述归并原理:
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述在这里插入图片描述

5.2 代码实现

public class Merge {
    //归并所需要的辅助数组
    private static Comparable[] assist;

    /*
       比较v元素是否小于w元素
    */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w)<0;
    }

    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }


    /*
           对数组a中的元素进行排序
        */
    public static void sort(Comparable[] a) {
        //1.初始化辅助数组assist；
        assist = new Comparable[a.length];
        //2.定义一个lo变量，和hi变量，分别记录数组中最小的索引和最大的索引；
        int lo=0;
        int hi=a.length-1;
        //3.调用sort重载方法完成数组a中，从索引lo到索引hi的元素的排序
        sort(a,lo,hi);
    }

    /*
    对数组a中从lo到hi的元素进行排序
     */
    private static void sort(Comparable[] a, int lo, int hi) {
        //做安全性校验；
        if (hi<=lo){
            return;
        }

        //对lo到hi之间的数据进行分为两个组
        int mid = lo+(hi-lo)/2;//   5,9  mid=7

        //分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);

        //再把两个组中的数据进行归并
        merge(a,lo,mid,hi);
    }

    /*
    对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
     */
    private static void merge(Comparable[] a, int lo, int mid, int hi) {
        //定义三个指针
        int i=lo;
        int p1=lo;
        int p2=mid+1;

        //遍历，移动p1指针和p2指针，比较对应索引处的值，找出小的那个，放到辅助数组的对应索引处
        while(p1<=mid && p2<=hi){
            //比较对应索引处的值
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++]=a[p2++];
            }
        }

        //遍历，如果p1的指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
        while(p1<=mid){
            assist[i++]=a[p1++];
        }
        //遍历，如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素放到辅助数组的对应索引处
        while(p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助数组中的元素拷贝到原数组中
        for(int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }

    }

}

5.3 测试

public class MergeTest {

    public static void main(String[] args) {
        Integer[] a = {8,4,5,7,1,3,6,2};
        Merge.sort(a);
        System.out.println(Arrays.toString(a));//{1,2,3,4,5,6,7,8}
    }
}

在这里插入图片描述

5.4 时间复杂度分析

最终得出的归并排序的时间复杂度为：log2(n)* 2^(log2(n))=log2(n)*n
根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn)

缺点：

  • 需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。

通过测试，发现希尔排序和归并排序在处理大批量数据时差别不是很大

六、 快速排序

6.1 排序原理

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

  2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；

  3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

  4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

切分原理：
5. 找一个基准值，用两个指针分别指向数组的头部和尾部；

  1. 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；

  2. 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；

  3. 交换当前左边指针位置和右边指针位置的元素；

  4. 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。

  5. 当两个指针相遇时,该索引处值与基准值交换

在这里插入图片描述

6.2 代码实现

public class Quick {
    /*
      比较v元素是否小于w元素
   */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    /*
   数组元素i和j交换位置
    */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    //对数组内的元素进行排序
    public static void sort(Comparable[] a) {
        int lo = 0;
        int hi = a.length-1;
        sort(a,lo,hi);
    }

    //对数组a中从索引lo到索引hi之间的元素进行排序
    private static void sort(Comparable[] a, int lo, int hi) {
        //安全性校验
        if (hi<=lo){
            return;
        }

        //需要对数组中lo索引到hi索引处的元素进行分组（左子组和右子组）；
        int partition = partition(a, lo, hi);//返回的是分组的分界值所在的索引，分界值位置变换后的索引

        //让左子组有序
        sort(a,lo,partition-1);

        //让右子组有序
        sort(a,partition+1,hi);
    }

    //对数组a中，从索引 lo到索引 hi之间的元素进行分组，并返回分组界限对应的索引
    public static int partition(Comparable[] a, int lo, int hi) {
       //确定分界值
        Comparable key = a[lo];
        //定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
        int left=lo;
        int right=hi+1;

        //切分
        while(true){
            //先从右往左扫描，移动right指针，找到一个比分界值小的元素，停止
            while(less(key,a[--right])){
                if (right==lo){
                    break;
                }
            }

            //再从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
            while(less(a[++left],key)){
                if (left==hi){
                    break;
                }
            }
            //判断 left>=right,如果是，则证明元素扫描完毕，结束循环，如果不是，则交换元素即可
            if (left>=right){
                break;
            }else{
                exch(a,left,right);
            }
        }

        //交换分界值
        exch(a,lo,right);

       return right;
    }

}

6.3 测试

public class QuickTest {
    public static void main(String[] args) {
        Integer[] a= {6, 1, 2, 7, 9, 3, 4, 5, 8};
        Quick.sort(a);
        System.out.println(Arrays.toString(a));//{1, 2, 3, 4, 5, 6, 7, 8, 9}
    }
}

在这里插入图片描述

6.4 时间复杂度分析

  • 因此快速排序的最差时间复杂度和冒泡排序是一样的都是 O ( n^2^ )
  • 它的平均时间复杂度为 O ( n log ⁡~2~ n )

七、 排序的稳定性

数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个该算法是稳定的。

如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。例如要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需要重新排序。这样既可以保持第一次排序的原有意义，而且可以减少系统开销。

在这里插入图片描述 冒泡排序 \color{#0AF}{冒泡排序} 冒泡排序
​只有当arr[i]>arr[i+1]的时候才会交换元素的位置而相等的时候并不交换位置，所以冒泡排序是一种稳定排序算法。

选择排序 \color{#0AF}{选择排序} 选择排序
​ 选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8 ，5(2)， 2， 9 },第一遍选择到的最小元素为2，所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。

插入排序 \color{#0AF}{插入排序} 插入排序
​ 比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定。

希尔排序 \color{#0AF}{希尔排序} 希尔排序
​ 希尔排序是按照不同步长对元素进行插入排序 ,虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。

归并排序 \color{#0AF}{归并排序} 归并排序
​ 归并排序在归并的过程中，只有arr[i]<arr[i+1]的时候才会交换位置，如果两个元素相等则不会交换位置，所以它并不会破坏稳定性，归并排序是稳定的。

快速排序 \color{#0AF}{快速排序} 快速排序
​ 快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素，然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法。

在这里插入图片描述在这里插入图片描述

Dream_sky分享
关注
专栏目录
python列表中元素值进行比较_Python小练习之使用for循环对列表内元素进行排序
weixin_39531178的博客
11-26 1655
list = [13, 22, 6, 99, 11]for m in range(len(list)-1):for n in range(m+1, len(list)):if list[m]> list[n]:temp = list[n]list[n] = list[m]list[m] = tempprint list结果：[6, 11, 13, 22, 99]分析：list = [13, 22,...
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
排序算法~
weixin_44742328的博客
05-10 173
简单排序 一、冒泡排序 排序原理： 1.比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。 2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大 值。 public class Bubble { public static void main(String[] args) { int[] a = { 5, 8, 4, 9, 10, 6 }; for (int i = 0; i <= a.length - 1; i++) {
数组里面相同key值_3. for循环对比两个数组~Check Array Formation
weixin_28323057的博客
01-29 805
今天的题比较简单，自己做出来了。就是一个数组里面是一堆数字，另外一个数组里面是一堆子数组，判断后面这个数组随便排序，能不能和前面的数组里的数字 一样。做是做出来了，但是时间效率低。瞅了一眼旁边我老公的答案，他的比我的效率高。题目如下：我俩的答案区别如下：我的是经历了三轮循环：第一轮把右边这个数组，弄成key-value的dictionary；第二轮循环左边这个数组，看这个数字在dictionary...
For循环判断数组元素是否全部相等
weixin_42047392的博客
03-31 1万+
判断所选中的行里的某个数据是否全部相等（我这里判断的是所选行的客户名称是否全部相等）。 首先要获取整行的记录值，我这里用的是BsgridPage表格，所以我用了（gridObj.getCheckedRowsRecords()
php循环比较数组中的值,如何从PHP数组中计算值并在foreach循环中仅显示一次值？...
weixin_39798943的博客
03-10 186
假设以下是我们的PHP数组$listOfNames=array('John','David','Mike','David','Mike','David');我们希望输出在上面的数组中显示值的计数，如下所示：Array([John]=>1[David]=>3[Mike]=>2)要获取计数，请使用内置函数array_count_values()。示例PHP代...
十种经典排序算法总结
天瑕的博客
04-06 1万+
如果面试时让你写排序算法，除了说一句Arrays.sort你还会啥？
十大经典排序算法总结整理
ytusdc的博客
10-12 6016
参考文章： 十大经典排序算法最强总结：https://www.cnblogs.com/guoyaohua/p/8600214.html 排序算法总结:https://www.runoob.com/w3cnote/sort-algorithm-summary.html 术语说明 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数...
七大经典排序算法总结详解
12-29
本文将详细讲解七大经典排序算法，帮助你深入理解它们的工作原理、优缺点以及适用场景。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，通过重复遍历数组，比较相邻元素并交换位置来实现排序。如果...
C、C++经典排序算法总结.pdf
10-14
【C、C++经典排序算法总结】 排序算法是计算机科学中的重要组成部分，尤其在处理大量数据时，高效的排序算法能够显著提升程序性能。本篇主要介绍两种基础且经典的排序算法：选择排序和直接插入排序。 1. **稳定...
八大经典排序算法总结和源代码
09-18
八大经典排序算法总结和源代码 在计算机科学中，排序算法是最基本也是最重要的算法之一。排序算法的性能直接影响到整个系统的性能。今天，我们将总结八大经典排序算法，并提供C++实现的源代码。 一、稳定排序和...
【笔试】python刷题笔记（基础）！
热门推荐
a_123456598的博客
05-04 11万+
1. while True: try: do something except: break while True 必须和break结合，无异常时执行try，异常时执行except，break退出循环。 2.raw_input()与input() python2 存在raw_input()和input()两个函数 raw_input()...
Python中给定一个数组a = [2,3,9,1,0]，找出其中最大的一个数，并打印出来 求解?
分享Python、数据分析、人工智能前沿知识
09-14 323
是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。通过排序算法得到顺序列表后，通过索引就可以得到最大值，so easy！如果不用内置函数，自己排序算法来找出最大值，也有很多选择。比如冒泡排序、循环排序、交换排序、插入排序、选择排序等等。
排序算法-冒泡排序
sbdd6556的博客
09-14 373
冒泡排序
代码随想录算法训练营Day7
最新发布
lynyzy的博客
09-18 443
双指针
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 352
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 7277
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
C语言实现七大经典排序算法总结
本文档是一篇关于七大经典排序算法的总结，以C语言描述，作者是Vincent，发表于2018年11月9日的博客园。主要内容分为以下几个部分： 1. 交换排序：这是基于比较元素之间大小关系来调整位置的排序方法。 - **冒泡...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dream_sky分享

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值