经典算法——排序算法

于 2021-09-01 16:27:32 发布
阅读量2.2k 收藏 2
点赞数 2
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axibazZ/article/details/120034900
版权

冒泡排序

排序原理：

  1. 比较相邻的元素，如果前一个元素比后一个元素大，就交换两个元素的位置。
  2. 对每一对相邻的元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置为最大值。

 冒泡排序API设计

类名Bubble描述
构造方法Bubble()创建Bubble对象
成员方法public static void sort(Comparable[] a)对数组内的元素进行排序
private static boolean greater(Comparable v, Comparable w)判断v是否大于w
private static void exch(Comarable[] a, int i, int j)交换数组中索引i和索引j处的值

冒泡排序的代码实现：

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])){
                    exch(a,j,j+1);
                }
            }
            System.out.println("第"+(a.length - i)+"次排序结果"+Arrays.toString(a));
        }
    }
    /**
     * 比较元素的大小
     */
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    /**
     * 交换元素的位置
     */
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试代码如下

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

测试结果打印

 

 冒泡排序的时间复杂度分析

冒泡排序使用了双层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

总的执行次数为：

N^2/2-N/2 + N^2/2-N/2 = N^2-N

所以冒泡排序的时间复杂度为O(N^2)

选择排序

选择排序原理：

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

 

选择排序API设计

类名Selection描述
构造方法Selection()创建Selection对象
成员方法public static void sort(Comparable[] a)对数组内的元素进行排序
private static boolean greater(Comparable v, Comparable w)判断v是否大于w
private static void exch(Comarable[] a, int i, int j)交换数组中索引i和索引j处的值

选择排序的代码实现

public class Selection {
    /**
     * 排序方法
     */
    public static void sort(Comparable[] a){
        for (int i = 0; i < a.length - 1; i++){
            //设置最小索引值为i
            int minIndex = i;
            for (int j = i+1; j < a.length; j++){
                if (greater(a[minIndex],a[j])){
                    //交换最小值索引
                    minIndex = j;
                }
            }
            //交换i索引和minIndex索引处的值
            exch(a,i,minIndex);
            System.out.println("第"+(i+1)+"次排序结果"+ Arrays.toString(a));
        }
    }
    /**
     * 比较元素的大小
     */
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    /**
     * 交换元素的位置
     */
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试代码

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

打印结果如下：

选择排序时间复杂度分析：

选择排序使用了双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分析选择排序的时间复杂度，主要分析交换次数和数据比较次数即可。

元素比较的次数为：

(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2 = N^2/2-N/2

元素交换的次数为：

N-1

总的执行次数为：

N^2/2-N/2 + N-1 = N^2+N/2 -1

所以选择排序的时间复杂度为O(N^2)。

插入排序

插入排序原理：

  1. 把所有的元素分为两组，已经排序的和未排序的。
  2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入。
  3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么久把待插入元素放到这个位置，其他元素向后移动一位。

插入排序API设计

类名Insertion描述
构造方法Insertion()创建Insertion对象
成员方法public static void sort(Comparable[] a)对数组内的元素进行排序
private static boolean greater(Comparable v, Comparable w)判断v是否大于w
private static void exch(Comarable[] a, int i, int j)交换数组中索引i和索引j处的值

插入排序代码实现

 

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])){
                    exch(a,j-1,j);
                }else{
                    break;
                }
            }
            System.out.println("第"+(i)+"次排序结果"+ Arrays.toString(a));
        }
    }
    /**
     * 比较元素的大小
     */
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    /**
     * 交换元素的位置
     */
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试代码

public class Test {
    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));
    }
}

测试结果打印

插入排序时间复杂度分析

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

元素比较的次数为：

(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

总执行次数为：

N^2/2-N/2 + N^2/2-N/2 = N^2-N

所以插入排序时间复杂度为O(N^2)。

希尔排序

希尔排序原理：

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

 增长量h的确定：增长量h的值没有固定的规则，我们这里采用以下规则：

int N = a.length;
//确定增长量h的最大值
int h=1;
while(h<N/2){
  h=h*2+1;
}

//h的减少规则为
h=h/2;

 希尔排序的API设计：

类名Shell描述
构造方法Shell()创建Shell对象
成员方法public static void sort(Comparable[] a)对数组内的元素进行排序
private static boolean greater(Comparable v, Comparable w)判断v是否大于w
private static void exch(Comarable[] a, int i, int j)交换数组中索引i和索引j处的值

 希尔排序的代码实现

public class Shell {
    /**
     * 排序方法
     */
    public static void sort(Comparable[] a){
        int len = a.length;
        int h = 1;
        while (h < len/2){
            h = h*2+1;
        }
        while (h>=1){
            //找到待插入的元素
            for (int i=h;i<len;i++){
                //把a[i]插入到a[i-h],a[i-2h]...序列中
                for (int j=i;j>=h;j-=h){
                    //把a[j]就是待插入元素，依次和a[j-h],a[j-2h]进行比较，
                    // 如果a[j]小，那么交换位置，如果不小于，a[j]大，则插入完成
                    if (greater(a[j-h],a[j])){
                        exch(a,j,j-h);
                    }else{
                        break;
                    }
                }
            }
            System.out.println("h="+h+",排序结果:"+ Arrays.toString(a));
            h/=2;
        }
    }
    /**
     * 比较元素的大小
     */
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    /**
     * 交换元素的位置
     */
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试代码：

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

测试打印结果：

 

归并排序

归并排序原理：

  1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
  2. 将相邻的两个子组进行合并成一个有序的大组。
  3. 不断的重复步骤2，直到最终只有一个组为止。

 归并排序API设计

类名Merge描述
构造方法Merge()创建Merge对象
成员方法public static void sort(Comparable[] a)对数组内的元素进行排序
private static void sort(Comparable[] a, int lo, int hi)对数组从索引lo到索引hi之间的元素进行排序
private static void merge(Comparable[] a, int lo, int mid, int hi)从索引lo到索引mid为一个子组，从索引mid+1到索引hi为另个一子组，把数组a中的这两个子组的数据合并到一个有序的大组（从索引lo到索引hi）
private static boolean less(Comparable v, Comparable w)判断v是否小于w
private static void exch(Comarable[] a, int i, int j)交换数组中索引i和索引j处的值
成员变量private static Comparable[] assist完成归并操作需要的辅助数组

 归并排序算法代码如下：

public class Merge {
    private static Comparable[] assist;
    /**
     * 排序方法
     */
    public static void sort(Comparable[] a){
        assist = new Comparable[a.length];
        int lo = 0;
        int hi = a.length -1;
        sort(a, lo, hi);
    }

    /**
     * 对数组中从lo到hi的元素进行排序
     */
    private static void sort(Comparable[] a, int lo, int hi){
        if (hi <= lo){
            return;
        }
        int mid = lo + (hi - lo)/2;
        //对lo到mid之间的元素进行排序
        sort(a, lo, mid);
        //对mid+1到hi之间的元素进行排序
        sort(a, mid+1, hi);
        //对lo到mid这组数据和mid到hi这组数据进行归并
        merge(a,lo,mid,hi);
    }

    /**
     * 对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
     */
    private static void merge(Comparable[] a, int lo, int mid, int hi){
        //定义一个指针，指向assist数组中开始填充数据的索引
        int i = lo;
        //定义一个指针，指向第一组数据的第一个元素
        int p1 = lo;
        //定义一个指针，指向第二组数据的第一个元素
        int p2 = mid + 1;
        //比较左边小组和右边小组中的元素大小，哪个小就把哪个数据填充到assist数组中
        while (p1 <= mid && p2 <= hi){
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++] = a[p2++];
            }
        }
        //上面的循环结束后，如果退出循环的条件是p1<=mid，则证明左边小组中的数据已经归并完毕，
        // 如果退出循环的条件是p2<=hi,则证明右边小组的数据已经填充完毕；
        //所以需要把未填充完毕的数据继续填充到assist中,//下面两个循环，只会执行其中的一个
        while (p1<=mid){
            assist[i++] = a[p1++];
        }
        while (p2<=hi){
            assist[i++] = a[p2++];
        }
        //到现在为止，assist数组中，从lo到hi的元素是有序的，再把数据拷贝到a数组中对应的索引处
        for (int index=lo; index <= hi; index++){
            a[index] = assist[index];
        }
        System.out.println("lo="+lo+",hi="+hi+",合并排序结果:"+ Arrays.toString(a));
    }

    /**
     * 比较元素的大小
     */
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    /**
     * 交换元素的位置
     */
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试代码如下：

public class Test {
    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. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

 快速排序API设计

类名Quick描述
构造方法Quick()创建Quick对象
成员方法public static void sort(Comparable[] a)对数组内的元素进行排序
private static void sort(Comparable[] a, int lo, int hi)对数组从索引lo到索引hi之间的元素进行排序
private static int partition(Comparable[] a, int lo, int hi)对数组a中从索引lo到索引hi之间的元素进行排序
private static boolean less(Comparable v, Comparable w)判断v是否小于w
private static void exch(Comarable[] a, int i, int j)交换数组中索引i和索引j处的值

 切分原理：

把一个数组切分成两个子数组的基本思想：

  1. 找一个基准值，用两个指针分别指向数组的头部和尾部；
  2. 先找尾部向头部开始搜素一个比基准值小的元素，搜素到即停止，并记录指针的位置；
  3. 再从头部向尾部开始搜素一个比基准值大的元素，搜素到即停止，并记录指针的位置；
  4. 交换当前左边指针位置和右边指针位置的元素；
  5. 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。

快速排序代码实现：

public class Quick {
    /**
     * 排序方法
     */
    public static void sort(Comparable[] a){
        int lo = 0;
        int hi = a.length - 1;
        sort(a,lo,hi);
    }

    /**
     * 对数组中从lo到hi的元素进行排序
     */
    private static void sort(Comparable[] a, int lo, int hi){
        if (hi <= lo){
            return;
        }
        //对a数组中，从lo到hi的元素进行切分
        int partition = partition(a, lo, hi);
        //对左边分组中的元素进行排序
        sort(a,lo,partition-1);
        //对右边分组中的元素进行排序
        sort(a,partition+1,hi);
    }

    /**
     * 对数组进行切分
     */
    private static int partition(Comparable[] a, int lo, int hi){
        //把最左边的值作为基准值
        Comparable key = a[lo];
        //定义一个左侧指针，初始指向最左边的元素位置
        int left = lo;
        //定义一个右侧指针，初始指向最右侧的元素下一个位置
        int right = hi + 1;
        //进行切分
        while (true){
            //先从右边往左扫描，找到一个比基准值小的元素
            //循环停止，证明找到了一个比基准值小的元素
            while (less(key,a[--right])){
                if (right == lo){
                    break;
                }
            }
            //再从左往右扫描，找一个比基准值大的元素
            //循环停止，证明找到了一个比基准值大的元素
            while(less(a[++left],key)){
                if (left==hi){
                    //已经扫描到了最右边了，无需继续扫描
                    break;
                }
            }

            if (left>=right){
                //扫描完了所有元素，结束循环
                break;
            }else{
                //交换left和right索引处的元素
                exch(a,left,right);
            }
        }
        //交换最后right索引处和基准值所在索引处的位置
        exch(a, lo, right);
        System.out.println("基准值为"+key+",切分后的顺序"+Arrays.toString(a));
        //right就是切分的界限
        return right;
    }

    /**
     * 比较元素的大小
     */
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    /**
     * 交换元素的位置
     */
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

}

测试代码：

public class Test {
    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));
    }
}

测试打印结果：

 

傲傲娇
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速排序
weixin_30819085的博客
07-04 324
　　快速排序是由C.A.R Hoare在1960年发明的，并被选为20世纪十大算法。在不要求稳定的应用场景中，快速排序是一种性能不错的、通用的排序算法。 　　在阅读完Robert Sedgewick的《算法》之后，尝试把几种快速排序整理在一起并总结。快速排序的精髓在于切分位置（Partition）的选取，本文希望把重点放在几种切分的区别上，淡化快速排序的原理和概念。本文所有源...
【JZOJ 5220】【GDOI2018模拟7.10】C
07-11 442
Description设A、B两字符串的最长公共公共前缀长度为L，那么在A串所有长度为L的子串中，有多少个同时是B的子串。Solution把题目改成：“A、B串中所有长度为L的子串，有多少个是两两相同的”，那么这个直接用求最长公共子串的DP加上统计方案数即可，注意细节；那么这题怎么做呢？ 设i,j,k，保证ai=aj,ai=ak,j<ka_i=a_j,a_i=a_k,j<k这三个条件 那么有结论
算法最简单之希尔算法
laokdidiao的专栏
07-31 2256
公共函数： less： public static boolean less(Comparable v , Comparable w){ return v.compareTo(w) < 0; } exch： public static void exch(Comparable[] a, int i ,int j){ Comparable t = a[i]; a[i] = a[j];
JZOJ 5221. 【GDOI2018模拟7.10】A
Felix-Lee的博客
07-11 356
JZOJ 5221. 【GDOI2018模拟7.10】A DescriptionInputOutputSample Input4 2 3 2 1 2 4Sample Output4Data ConstraintSolution 首先，这是一棵有根树，先要找到它的根是哪个节点。 由于边是有向边，入度为零的点就是根节点了。 接着，如何处理出答案呢？ 从根节点开始遍历这棵树，
分治算法——归并排序
12-21
分治法——归并排序 归并排序操作过程： def mergesort(seq): #归并排序 if len(seq) <= 1: return seq mid = int(len(seq) / 2) # 将列表分成更小的两个列表 # 分别对左右两个列表进行处理，分别返回两个...
算法课设——排序重构问题
05-18
4.排序重构问题。令A为一个由N个已特殊排序数组成的数列：A1，A2，…，AN，其中A1=0。令B为N（N-1）/2个数（定义为Dij=Ai-Aj(i>j)）组成的数列。例如，A=0，1，5，8，那么D=1，3，4，5，7，8。请完成： a）编写程序...
经典算法大全——-pdf
09-12
《经典排序算法》是其中的一个重要章节，包括冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等。每种排序算法都有其独特的思想和适用场景，例如冒泡排序适合小规模数据，快速排序则以其高效的平均性能在...
VB常用算法——排序.doc
10-03
标题中的“VB常用算法——排序”指的是在Visual Basic编程环境中常用的排序算法，这些算法用于对一组数据进行排序，使得数据按照特定的顺序排列。在这个文档中，提到了两种常见的排序算法：选择法排序和冒泡法排序。...
奔走在算法的大路上（一）排序之插入排序
我的编程之路
04-07 919
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 其原理我感觉用一张图说明时最好的了 源码 packa
python字符串索引前面比后面大_Python编程题12--列表中比前面元素都大，比后面元素都小的数...
weixin_39786141的博客
12-05 636
题目给定一个无序列表，列表中元素均为不重复的整数。请找出列表中有没有比它前面元素都大，比它后面的元素都小的数，如果不存在则返回-1，存在则显示其索引。实现思路1利用 列表 结合 max() 、min() 内置函数来实现遍历列表，并通过 max() 、min() 分别求出当前元素在列表左侧的最小数、在列表右侧的最大数比较当前元素，是否满足比前面元素都大，比后面元素都小的条件，如果符合则将其对应的索引...
NOIP模拟题 2016.11.7 [DP*3]
C'est la vie.
11-07 870
A 问题描述： 小A得到了一棵美丽的有根树。这棵树由n个节点以及n - 1条有向边构成，每条边都从父亲节点指向儿子节点，保证除了根节点以外的每个节点都有一个唯一的父亲。树上的节点从1到n标号。该树的一棵子树的定义为某个节点以及从该节点出发能够达到的所有节点的集合，显然这棵树共有n棵子树。小A认为一棵有根树是美丽的当且仅当这棵树内节点的标号构成了一个连续的整数区间。现在小A想知道这棵树上共有多少棵
排序-选择排序-Java
Recar的博客
05-31 373
这个要看算法啊，看了算法第四版 写了笔记，想了想还是放在博客上。是分享也是方便。定义了一个排序算法的模板类 包含排序算法sort，less比较，exch交换还有show输出和isShorted判断是否是有序的传入的参数是Compareble，因为都实现了接口 。所以~ 比较利用的默认的compareTo方法 这个方法的调用者小于传入者则返回-1 相等返回0 大于返回1 然后让其返回值判断是
noip模拟题11.7
某炒鸡无底蒟蒻的博客
11-07 399
T1 A题问题描述： 小A得到了一棵美丽的有根树。这棵树由n个节点以及n - 1条有向边构成，每条边都从父亲节点指向儿子节点，保证除了根节点以外的每个节点都有一个唯一的父亲。树上的节点从1到n标号。该树的一棵子树的定义为某个节点以及从该节点出发能够达到的所有节点的集合，显然这棵树共有n棵子树。小A认为一棵有根树是美丽的当且仅当这棵树内节点的标号构成了一个连续的整数区间。现在小A想知道这棵树上共有
compareto排序_排序之选择排序
weixin_39835991的博客
11-23 283
我们关注的对象是重新排列数组元素的算法，其中每个元素都有个主键，当然这个主键并不是数据库的primary key,数据库的主键是唯一的，而我们元素的主键是按照某种方式排列，例如数字大小（1，2，3....）又例如字母排序（a，b，c.....）.元素通常是对象，而主键通常是通过一种内置的机制 。（comparable接口），一般来说，索引较大元素的主键大于索引较小元素的主键。因为结果相同，只是实现...
11月7日——离noip还有12天
lemonoil的博客
11-08 795
11月7日——离noip还有12天 高中第一次这么认真地整理题~~~ 目录 11月7日离noip还有12天 目录 A题 问题描述 代码dfs就可以了 B题 问题描述 题解 标答一 标答二 C题 问题描述 题解 正解 summary 博主郑重承诺以后的博客上一题一图片 本次考试没有用黑科技（random），就GG了； 感觉内心很惶恐，吃枣药丸。 A题 问
简单排序算法汇总（算法四版）
昆仑-郑教主的专栏
09-13 588
排序算法是重新排列数组元素的算法，而每一个元素都有一个主键，目的就是将所有元素的主键按照某种方式进行排列（大小或字母顺序）            我列出排序算法的模板：                                             sort()方法，将排序代码放在该方法中；                                             le
【看图识算法】这是你见过最简单的 “算法说明书”
weixin_33893473的博客
03-19 187
Quicksort算法 快速排序（Quicksort）是基于“分治法”的高效排序算法。随机选择划分元素是避免最坏情况runtime好策略。 Bogo排序 Bogo排序（Bogo sort）也称为愚蠢排序，是一种简单但效率非常低的排序算法。这个排序算法基于可能性，其原理等同将一堆卡片抛起，落在桌上后检查卡片是否已整齐排列好，若非就再抛一次，直到正确排...
学习排序算法1
bobo1356的博客
05-23 476
/*看算法4，第二章内容摘录。*/ //排序算法类的模板 package paixu; public class Example { //排序 public void sort(Comparable[] a){ } //判断v是否小于w protected static boolean less(Comparable v,Comparable w){ return v.co
实验一 算法的时间复杂度.pdf
最新发布
02-22
实验内容包括四种经典的排序算法：起泡排序、简单选择排序、快速排序和归并排序。 一、实验目的与要求 实验的目的是使学生熟悉C/C++的开发环境，并通过实际操作加强他们对算法分析基础的理解。这包括学习如何评估和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值