精华内容
下载资源
问答
  • 冒泡排序和选择排序

    万次阅读 多人点赞 2018-04-18 20:14:40
    冒泡排序1.1思想冒泡排序的思想是比较两两相邻的关键字,如果反序则进行交换,直到没有反序的为止。设想一个数组按照升序排列,经过第一轮比较之后最大的数就被放在最后了,因此剩下的比较中就不需要将它再参与进来...

    两个比较简单的排序算法就放到一起写了

    1.冒泡排序

    1.1思想

    冒泡排序的思想是比较两两相邻的关键字,如果反序则进行交换,直到没有反序的为止。设想一个数组按照升序排列,经过第一轮比较之后最大的数就被放在最后了,因此剩下的比较中就不需要将它再参与进来,第二轮比较中第二大的数据被放在了倒数第二的位置,它的位置也就股定了,也不需要参与剩余的比较。因此我们需要两层循环,外层循环控制比较的轮数,和数组元素的个数有关,内层循环控制需要参与比较的元素个数,和外层循环的轮数有关,当比较的轮数增大时,已经找到位置的元素个数随之增大,那么内层待比较的元素个数随之减小。

    1.2代码

    #include <iostream>
    using namespace std;
    
    void BubbleSortUp(int k[], int len) {
        int i, j, temp, count1 = 0, count2 = 0;
        for (i = 0; i < len - 1; i++) {
            for (j = 0; j < len - 1 - i; j++) {
                count1++;
                if (k[j] > k[j + 1]) {
                    count2++;
                    temp = k[j + 1];
                    k[j + 1] = k[j];
                    k[j] = temp;
                }
            }
        }
        cout << "总共进行了" << count1 << "次比较, " << count2 << "次移动" << endl;
    }
    
    int main() {
        int i;
        int arr[10] = {1, 3, 15, 2, 4, 17, 8, 6, 9, 0};
        BubbleSortUp(arr, 10);
        cout << "after sort: arr =  " << endl;
        for (i = 0; i < 10; i++) {
            cout << arr[i] << ' ';
        }
        cout << endl;
    
        return 0;
    }

    输出为:

    总共进行了45次比较, 19次移动
    after sort: arr =

    0 1 2 3 4 6 8 9 15 17

    2.选择排序

    2.1思想

    选择排序的思想是:假设一个数组按照升序排序,那么第一轮选出一个最小的元素放在0的位置,之后这个元素的位置就不需要再动了,第二轮选出剩余元素中最小的一个放在1的位置,如此循环。因此需要两层循环,外层循环控制选择的轮数,和数组长度有关,内层循环负责在剩余元素中寻找最小的一个,找到后将其放在合适的位置。如下图为排序前数组


    第一轮发现最小的是元素1,将其放在0的位置


    紧接着发现2是剩余元素中最小的一个,再将其放在1的位置


    2.2代码

    #include <iostream>
    using namespace std;
    
    void SelectSort(int k[], int len) {
        int temp, min;
        for (int i = 0; i < len - 1; i++) {
            min = i;
            for (int j = i + 1; j < len; j++) {
                if (k[j] < k[min])
                    min = j;
            }
    
            if (min != i) {
                temp = k[min];
                k[min] = k[i];
                k[i] = temp;
            }
        }
    }
    
    int main() {
        int i;
        int arr[10] = {1, 3, 15, 2, 4, 17, 8, 6, 9, 0};
        SelectSort(arr,10);
        cout << "after sort: arr =  " << endl;
        for (i = 0; i < 10; i++) {
            cout << arr[i] << ' ';
        }
        cout << endl;
    
        return 0;
    }

    3.总结

    对于选择排序,它的思想比较简单,但是由于是每次循环选择一个对应的元素将其放在正确的位置上,因此选择循环的两层循环都必须完全执行,因此对于任何情况下它的效率都是比较慢的。

    展开全文
  • Java的冒泡排序和选择排序的实现

    千次阅读 2020-03-28 11:08:10
    介绍了Java数组的冒泡排序和选择排序的实现。

    介绍了Java数组的冒泡排序和选择排序的实现。

    更多详尽的排序算法:10种常见排序算法原理详解以及Java代码的完全实现

    1 选择排序

    使用第一个值依次与后面的值做比较,若比第一个值小,交换位置,一轮结束后,将最小的值排在最前方.再拿第二个值与后面的值依次作比较,直至倒数第二个值完成比较,即完成排序。

    外层循环控制第一个数。内层循环控制第二个数。

    for (int i = 0; i < arr.length - 1; i++) {
        //第一个被比较的数
        for (int j = i + 1; j < arr.length; j++) {
            //被比较的数后面的数
            if (arr[i] > arr[j]) {
                arr[i] = arr[i] ^ arr[j];
                arr[j] = arr[i] ^ arr[j];
                arr[i] = arr[i] ^ arr[j];
            }
        }
    }
    System.out.println(Arrays.toString(arr));
    
    

    2 冒泡排序

    将前一个数和后一个数进行比较,若前一个比后一个小则交换位置,一轮完成后将最大值排在最前方再开始第二轮,选出第二大的值,排在倒数第二的位置,直至排到顺数第二位置,完成排序。

    外层循环控制循环次数,内层循环控制比较的两个数。

    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                arr[j] = arr[j] ^ arr[j + 1];
                arr[j + 1] = arr[j] ^ arr[j + 1];
                arr[j] = arr[j] ^ arr[j + 1];
            }
        }
    }
    System.out.println(Arrays.toString(arr));
    
    

    3 使用API方法

    使用位于util包的Arrays工具类的sort方法

    public static void sort(int[] a)

    部分排序:

    public static void sort(int[] a,int fromIndex,int toIndex)
    参数: a - 要排序的数组 fromIndex - 要排序的第一个元素的索引(包括) toIndex -
    要排序的最后一个元素的索引(不包括)

    补充

    DualPivotQuicksort是JDK1.7开始的类,采用的双Pivot快速排序算法, 这种算法通常会比传统单Pivot的快排算法效率更高,也是sort底层的算法! 并且针对不同类型的数组,其快速排序的算法也不一样!均封装在DualPivotQuicksort类中,形成重载方法,由sort方法根据传入的数组类型的不同而调用!

    更多详尽的排序算法:10种常见排序算法原理详解以及Java代码的完全实现

    如有需要交流,或者文章有误,请直接留言。另外希望点赞、收藏、关注,我将不间断更新各种Java学习博客!

    展开全文
  • C++篇——C++实现冒泡排序和选择排序算法摘要冒泡法代码运行结果选择排序法代码运行结果 摘要 本文通过C++实现了两类基础且经典的排序算法(冒泡法和选择排序法)。 冒泡法 代码 #include <iostream> using ...

    C++篇——C++实现冒泡排序和选择排序算法

    摘要

    本文通过C++实现了两类基础且经典的排序算法(冒泡法选择排序法)。

    冒泡法

    代码

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    
        /** 需要排序的数组 */
        double array[] = {5.8,2.3,4.9,10.8,-50.2,20.4,19.5,23.8,10.9,100.2};
        /** 数组的长度 */
        int array_length = sizeof(array)/sizeof(double);
        cout << "length of array is : " << array_length << endl;
    
        // 冒泡法进行降序排序
        double temp;
    
        for(int i = 0; i < array_length-1; i++){
            for(int j=0; j < array_length-i-1; j++){
                if(array[j]<array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    
        // 输出排序结果
        int i = 0;
        while( i < array_length){
            cout << array[i] << "\t";
            i ++ ;
        }
        cout << endl; 
    }
    
    
    

    运行结果

    length of array is : 10
    100.2   23.8    20.4    19.5    10.9    10.8    5.8     4.9     2.3     -50.2
    
    

    选择排序法

    代码

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    
        /** 需要排序的数组 */
        double array[] = {5.8,2.3,4.9,10.8,-50.2,20.4,19.5,23.8,10.9,100.2};
        /** 数组的长度 */
        int array_length = sizeof(array)/sizeof(double);
        cout << "length of array is : " << array_length << endl;
        
        // 选择排序法进行排序
        double temp;
        for(int i=0; i < array_length - 1; i++){
            for(int j=i+1; j < array_length; j ++ )
            {
                if(array[j] > array[i]){
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    
        // 输出排序结果
        int i = 0;
        while( i < array_length){
            cout << array[i] << "\t";
            i ++ ;
        }
        cout << endl;
    }
    
    

    运行结果

    length of array is : 10
    100.2   23.8    20.4    19.5    10.9    10.8    5.8     4.9     2.3     -50.2
    
    

    by CyrusMay 2021 01 18

    一颗葡萄有多甜美
    用尽了所有的
    图腾和语言
    描写
    ——————五月天(仓颉)——————

    展开全文
  • 算法--数组冒泡排序和选择排序原理分析以及优缺点

    1.冒泡排序原理分析

    1.1冒泡排序

    从前往后后依次比较相邻两个元素大小,大的元素往后挪,比较完第一遍后,最大的元素排到了数组的最后一位(假设是从小到大排序)


    1.2原理分析:

    冒泡排序逻辑:若为从小到大排序

    • 第一个数与第二个数比较 - - 若第二个数大,则不交换位置,反之,交换位置
    • 根据上一步的结果:进行第二个数与第三个数比较 - - 若第三个数大,则不交换位置,反之,交换位置
    • 依次类推,完成与最后一个数的比较后,最大的数就被排到了末位。
    • 接着再排依照同样的方法,将第二大的数排在倒数第二位(注意:排好了的数,就不需要再与他们比较大小了)

    图解原理

    这里写图片描述


    1.3代码实现

    package 数组两种排序;
    
    import java.util.Arrays;
    
    //冒泡排序
    public class Test1 {
        public static void main(String[] args) {
            int[] arr={2,5,1,9,12,6,7};
            bubbleSort(arr);
            System.out.println("从小到大排序"+Arrays.toString(arr));
    
            bubbleSort2(arr);
            System.out.println("从大到小排序"+Arrays.toString(arr));
        }
    
        //1.冒泡排序--从小到大排序
        public static int[] bubbleSort(int[] arr){
            for (int i = 0; i < arr.length-1; i++) {
                //对于已经排好的元素就不用再做比较了,所以第二个for循环,值遍历到arr.length-i-1
                for (int j = 0; j < arr.length-i-1; j++) {
                    //相邻两数比较,前面的数大,则交换,否则不交换,这样循环完后,最大值被排到了最后一位
                    if(arr[j]>arr[j+1]){
                        int temp=arr[j+1];
                        arr[j+1]=arr[j];
                        arr[j]=temp;
                    }
                }
            }
            return arr;
        }
    
        //2.冒泡排序--从大到小排序    只是将if判断中大于号>,改为了小于号<
        public static int[] bubbleSort2(int[] arr){
            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]){
                        int temp=arr[j+1];
                        arr[j+1]=arr[j];
                        arr[j]=temp;
                    }
                }
            }
            return arr;
        }
    
    
    }
    

    2.选择排序原理分析

    2.1选择排序:

    在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止(假设为从小到大排序)


    2.2原理分析

    选择排序逻辑:若为从小到大排序

    • 第一次:对数组中所有数值进行比较,获得最小值下标,然后将最小值与第一个数交换
    • 第二次:对数组中剩余(除第一个数)数值进行比较,获得最小值下标,然后将最小值与第二个数交换
    • 依次类推,直至确定倒数第二个位置的数值

    图解原理

    这里写图片描述


    2.3代码实现

    package 数组两种排序;
    
    import java.util.Arrays;
    
    public class Test2 {
        public static void main(String[] args) {
            int[] arr = { 2, 5, 1, 9, 12, 6, 7 };
            chooseSort(arr);
            System.out.println("从小到大排序" + Arrays.toString(arr));
    
            chooseSort2(arr);
            System.out.println("从大到小排序" + Arrays.toString(arr));
        }
    
        // 1.选择排序--从小到大排序
        public static int[] chooseSort(int[] arr) {
            //遍历数组,获取指定的arr[i]去与
            for (int i = 0; i < arr.length - 1; i++) {
                int index = i;//存储最小值的下标
                for (int j = i + 1; j < arr.length; j++) {
                    //若arr[index]大,则改变索引,使arr[index]变为那个小的值,最后可以得到最小值的索引
                    if (arr[index] > arr[j]) {
                        index = j;
                    }
                }
    
                //若index和初始值i相同就没必要交换了
                if(index!=i){
                    //将最小值与arr[i]交换
                    int temp2 = arr[i];
                    arr[i] = arr[index];
                    arr[index] = temp2;
                }
    
            }
            return arr;
        }
    
        // 2.选择排序--从大到小排序   只是将if判断中大于号>,改为了小于号<
        public static int[] chooseSort2(int[] arr) {
            for (int i = 0; i < arr.length - 1; i++) {
                int index = i;
                for (int j = i + 1; j < arr.length; j++) {
                    if (arr[index] < arr[j]) {
                        index = j;
                    }
                }
    
                if(index!=i){
                    //将最小值与arr[i]交换
                    int temp2 = arr[i];
                    arr[i] = arr[index];
                    arr[index] = temp2;
                }
            }
            return arr;
        }
    }
    

    3.两种排序方式的比较

    3.1冒泡排序

    交换次数多,耗时耗资源
    

    3.2选择排序

    交换次数少,节省时间和资源
    
    展开全文
  • 【c语言】冒泡排序和选择排序

    万次阅读 多人点赞 2018-12-03 12:45:06
    1.冒泡排序 冒泡排序将一个列表中的两个元素进行比较,并将最小的元素交换到顶部。两个元素中较小的会冒到顶部,而较大的会沉到底部,该过程将被重复执行,直到所有元素都被排序。 冒泡排序示意图 以如图所示的...
  • 冒泡排序和选择排序的区别

    千次阅读 2018-06-11 20:30:05
    一、冒泡排序冒泡排序的时间复杂度为O(n^2),冒泡排序法是最简单基础的一种排序方法,但是它的时间复杂度较大,排序一组数组比较的次数较多。冒泡排序的具体操作过程:比较相邻的元素。如果第一个比第二个大,就交换...
  • 第一个原因:我和我的同学在学习java的排序过程中,冒泡排序和选择排序傻傻分不清楚。把这两个排序放在一起,可以帮助我们去更好的理解它们。 第二个原因:主要检验下自己自学的成果与问题。 那么好,咱们...
  • Java实现冒泡排序和选择排序

    千次阅读 2019-01-15 17:28:07
    冒泡排序:依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素已经排序完成。 冒牌排序是稳定排序法...
  • 使用java实现冒泡排序和选择排序

    万次阅读 多人点赞 2018-04-22 16:38:55
    冒泡排序原理 假设有10个数,第一轮循环,第一个数第二个数比较,如果第一个数大,第一个数第二个数交换位置,否则不动;接着第二个数第三个数比较,如果第二个数大,第二个数第三个数交换位置,否则不动...
  • 测试冒泡排序和选择排序的效率

    千次阅读 2019-04-17 14:36:30
    冒泡排序VS选择排序 public class SortCompare { public static void main (String[] args) { int[] arr = new int[10000];//测试10000个数的比较时间 //通过随机数初始化数组 for (int i = 0; i < ...
  • 【c++】冒泡排序和选择排序原理及实现

    千次阅读 多人点赞 2018-05-03 18:06:59
    【c++】冒泡排序和选择排序 1.冒泡排序 冒泡排序是一种稳定排序算法,时间复杂度为O(n)。原理: 冒泡排序算法的运作如下:(从后往前)(1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。(2)对每...
  • 数组中的冒泡排序和选择排序

    千次阅读 2018-11-06 14:34:29
    冒泡排序 例如:5个数 外层循环要排序4次,内层循环要是从4次逐层递减 public class BubblingSort { public static void bubblingSort(int[] array) { for(int i=0;i&lt;array.length-1;i++) { for(i...
  • 实现冒泡排序和选择排序

    千次阅读 2013-11-12 17:43:55
    1、冒泡排序  冒泡排序的思想就是:大数沉底,小数浮起。 它的做法是:对于n个需要排序的数,每次都把未排序的数中最大的数,放到它最终所在的位置。冒泡排序需要进行n-1趟。算法的C++语言实现如下: template ...
  • 一, 冒泡排序冒泡排序的定义就不提了,总结起来就一句话(划重点):,从左到右,数组中相邻的两个元素进行比较,将较大的放到后面。 算法思路: 1、比较相邻的元素。如果第一个比第二个大,就交换它们两个; ...
  • 之所以把冒泡排序和选择排序放在一起,是因为二者的实现代码很相似,而且都是最基本的排序方式,非常容易理解和实现。当然,如果仅仅是为了讲述这两种排序方式,那也根本没必要写这篇博文了。和上篇博文一样,我会在...
  • 今天主要说一下常见的算法 ,于是我百度了一下点进那 “ 牛逼 ” 的知乎看了一眼 ,...进入正题 ,我要说的几种算法就是二分法查找 ,冒泡排序和选择排序 。以数组为例 ,谈谈它们在 Java 中的实现 。 二分法查找...
  • 冒泡排序和选择排序以及封装

    千次阅读 2016-11-17 10:53:40
    选择排序选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 选择排序是不稳定...
  • 冒泡排序和选择排序流程图

    千次阅读 2018-06-11 09:38:47
    冒泡排序 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤,除了...
  • C#-冒泡排序和选择排序

    千次阅读 2015-12-25 15:53:28
    将一个数组排序 //排序 #include int main() { int a[]={3,5,2,56,275,85,29,24}; int temp,i,j; int length= sizeof(a) / sizeof(a[0]);//计算a[]的大小时,不要...//选择排序 for(i=0;i;i++){ for(j=i;j;j+
  • 冒泡排序冒泡排序的的优点是好理解,稳定,再就是空间复杂度低,不需要额外开辟数组元素的临时保存控件,当然了,编写起来也容易。 其算法很简单,就是比较数组相邻的两个值,把大的像泡泡一样“冒”到数组...
  • head> meta charset="UTF-8"> title>Documenttitle> script> ... 冒泡排序: 用来将一组没有顺序的数字,进行从大到小或者从小到大的排序方式进行重新排序。 选择排序(选择排序): 用来将一组
  • # 冒泡排序:从小到大 # 第一轮:1 5 3 2 7 # 第二轮:1 3 2 5 7 ''' n = len(lt) # 外层循环控制比较多少轮 for i in range(n-1): # 内层循环控制元素的比较 #for j in range(n-1): for j in range(n-i-1)...
  • 冒泡排序和选择排序的区别?

    千次阅读 2018-10-24 14:30:09
    在一次写选择排序算法的时候,发现和冒泡没啥区别,后来发现写错了,写的就是冒泡而非选择。先看一下期初的代码: template&lt;typename T&gt; vector&lt;T&gt; selectionSort(vector&lt;T&...
  • 冒泡排序和选择排序法的图示解析

    千次阅读 2016-11-22 00:25:14
    思路:在进行冒泡排序(升序)时,需要将数组元素(len)两两比较,如果 前面的元素大于后面的元素,则交换两个数,否则,比较下一个元素它的下一个元素的大小,依次执行,执行一次循环,可以找到当前数组中...
  • 1.冒泡排序:它的实现原理节省了时间, 实现原理:一组数两两进行比较,然后把最大数放在后边,这样每次循环结束都会少一次比较, /* * 冒泡排序 */ public class C { public static void main(String[] args) {...
  • Java排序算法之冒泡排序和选择排序

    千次阅读 2016-09-19 23:14:52
    } //冒泡排序 //结果:无结果 //参数:一个整型数组 public static void bubbleSort(int[] arr) { for(int i=0;i;i++) { for(int j=0;j;j++) { if(arr[j+1][j]) { huan(arr,j,j+1); ...
  • 排序:冒泡排序Bubble Sort 冒泡排序的算法思路在于对无序表进行多趟比较交换, 每趟包括了多次两两相邻比较, 并将逆序的数据项互换位置, 最终能将本趟的最大项就位 经过n-1趟比较交换, 实现整表排序 每趟的过程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 210,385
精华内容 84,154
关键字:

冒泡排序和选择排序