手把手教你搞懂冒泡排序和选择排序

目录
  • 冒泡排序
    • 原理:
  • 选择排序
    • 原理:
  • 总结

冒泡排序

原理:

从头(左边)开始比较每一对相邻的元素,如果第1个比第2个大,就交换它们的位置,执行完一轮后,最末尾(最右边)就是最大的元素。

举例:

假设存在数组nums={6,8,2,9,4},对nums数组进行排序

从左往右开始,拿出两个元素进行对比,出现两种情况:

1.左边元素 <= 右边元素,不变

2.左边元素 > 右边元素,交换他们的位置(这里可以写成>=吗?不行,因为会造成排序不稳定)

接下来就是新的一轮排序,逻辑跟上图的流程是一样的,不同的是会将最大的元素排除在外,不用进行比较。

手撕代码:

/*
没有使用过优化策略的冒泡排序
 */
public class BubbleSort1 {
    //测试数据
    public static int[] nums = {4,1,7,11,9,55};
    //main方法
    public static void main(String[] args){
        //这个for循环每循环完一次,end--,说明就把最大的元素给选出来了
        for (int end = nums.length - 1; end > 0; end--){
            for (int begin = 1; begin <= end; begin++){
                if(nums[begin] < nums[begin - 1]){    //每当发现左边的元素大于右边的元素
                    //交换元素
                    int temp = nums[begin];
                    nums[begin] = nums[begin - 1];
                    nums[begin - 1] = temp;
                }
            }
        }
        //打印验证结果
        for(int num : nums){
            System.out.print(num+"_");
        }
    }
}

时间复杂度为O(n^2),也就是n的平方,不过这是平均时间复杂度

存在最好时间复杂度O(n),那就是数组本来就有序,也就是说只扫描一遍就行了。

优化策略:

由于存在部分有序的情况,例如nums数组为{8,5,2,10,11,12},也就是说10,11,12都没有比较的必要了

优化代码:

/*
使用过优化策略的冒泡排序
 */
public class BubbleSort1 {
    public static int[] nums = {4,1,7,11,9,55};
    public static void main(String[] args){
        for (int end = nums.length - 1; end > 0; end--){
            int sortIndex = 1;  //记录最后一次交换位置
            for (int begin = 1; begin <= end; begin++){
                if(nums[begin] < nums[begin - 1]){
                    int temp = nums[begin - 1];
                    nums[begin - 1] = nums[begin];
                    nums[begin] = temp;
                    sortIndex = begin;
                }
                end = sortIndex;
            }
        }
        for(int num : nums){
            System.out.print(num+"_");
        }
    }
}

选择排序

原理:

从数组中找到最大的元素,然后与末尾(最右边)的元素交换位置,执行完一轮后,末尾(最右边)的那个元素就是最大的元素。

举例:

假设存在数组nums={5,8,1,9,3},对nums数组进行排序,准备一个maxIdex代表当前最大元素的下标

接下来就是新的一轮排序,逻辑跟上图的流程是一样的,不同的是会将最大的元素排除在外,不用进行比较。

手撕代码:

/**
 * 选择排序
 */
public class SelectionSort {
    //测试数据
    private static int[] nums = {6,3,2,8,9};
    //main方法
    public static void main(String[] args){
        //这个for循环每循环完一次,end--,说明就把最大的元素给选出来了
        for(int end = nums.length - 1; end > 0; end--){
            int maxIndex = 0;   //假设下标0是数组中最大元素
            for(int begin = 1; begin <= end; begin++){  //从左往右开始比较
                if(nums[maxIndex] < nums[begin]){   //发现存在一个元素大于假设最大元素
                    maxIndex = begin;   //更改最大元素索引
                }
            }
            //最右边一个元素和最大值元素交换位置
            int temp = nums[maxIndex];
            nums[maxIndex] = nums[end];
            nums[end] = temp;
        }
        //打印结果
        for(int num : nums){
            System.out.print(num+"_");
        }
    }
}

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注我们的更多文章!

(0)

相关推荐

  • java冒泡排序和选择排序详解

    目录 1.冒泡排序 2.选择排序法 总结 1.冒泡排序 冒泡排序(Bubble Sorting)的基本思想是:通过对待 排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒. 因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下 来没有进行过交换,就说明序列有序. 图解冒泡排序算法的过程 原始数组:3, 9, -1, 10, 20 第一趟排序 (1) 3, 9, -1, 10, 20 // 如果相邻

  • Python实现的插入排序,冒泡排序,快速排序,选择排序算法示例

    本文实例讲述了Python实现的插入排序,冒泡排序,快速排序,选择排序算法.分享给大家供大家参考,具体如下: #!/usr/bin/python # coding:utf-8 #直接插入排序 def insert_sort(list): for i in range(len(list)): Key = list [i] #待插入元素 j = i - 1 while(Key < list[j] and j >= 0): list[j+1] = list[j] #后移元素 list[j] = Ke

  • JavaScript算法学习之冒泡排序和选择排序

    前言 算法与数据结构构成了程序,数据结构用于实现数据的表示.存储.管理,算法通过使用数据完成一定的业务逻辑与操作,最终实现了程序的功能.因此算法在编程中的重要性是不言而喻的.很多复杂的算法都是借助最基本的算法实现的.本文主要选取经典排序算法中的冒泡排序与选择排序对JavaScript编程实现算法进行简单描述与说明. 程序算法 算法说明 算法(Algorithm)是解决问题的一种策略机制,算法也是有限操作指令的集合.按照算法策略输入符合要求的数据,最终获得解决问题的输出结果.冒泡算法与选择算法主要

  • java数组算法例题代码详解(冒泡排序,选择排序,找最大值、最小值,添加、删除元素等)

    数组算法例题 1.数组逆序 第一个和最后一个互换,第二个和倒数第二个互换,就相当于把数组想下图一样,进行对折互换,如果数组个数为奇数,则中间保持不变其余元素互换即可 import java.util.Arrays; class Demo12 { public static void main (String[] args) { int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; System.out.println(Arrays.toString(arr));

  • Java冒泡排序法和选择排序法的实现

    冒泡排序法和选择排序法 本人学生党一枚.Java学习过程,写这个博客纯属当复习,有什么错误的地方请大家指出来在评论里指点指点我.谢谢 冒泡排序法 概念: 从前向后(或从后向前)依次比较相邻的元素,若发现逆顺序,则交换.小的向前换,大的向后换,像水底的气泡逐渐向上冒,顾名思义冒泡排序法. 通俗一点就是把大的往上挪!向冒泡一样. 是交换式排序法的一种.冒泡排序法效率较低. 冒泡排序法思路 1:外层循环:控制它要走几次. 假设你有5个数,那就要走4次,最后一次不用走,最后那个数已经在它位置了所以就要l

  • 手把手教你搞懂冒泡排序和选择排序

    目录 冒泡排序 原理: 选择排序 原理: 总结 冒泡排序 原理: 从头(左边)开始比较每一对相邻的元素,如果第1个比第2个大,就交换它们的位置,执行完一轮后,最末尾(最右边)就是最大的元素. 举例: 假设存在数组nums={6,8,2,9,4},对nums数组进行排序 从左往右开始,拿出两个元素进行对比,出现两种情况: 1.左边元素 <= 右边元素,不变 2.左边元素 > 右边元素,交换他们的位置(这里可以写成>=吗?不行,因为会造成排序不稳定) 接下来就是新的一轮排序,逻辑跟上图的流程

  • Go语言实现冒泡排序、选择排序、快速排序及插入排序的方法

    本文实例讲述了Go语言实现冒泡排序.选择排序.快速排序及插入排序的方法.分享给大家供大家参考.具体分析如下: 算法是程序的灵魂,而排序算法则是一种最基本的算法.排序算法有许多种,这里介绍4中排序算法:冒泡排序,选择排序,快速排序和插入排序,以从小到大为例. 一.冒泡排序 冒泡排序的原理是,对给定的数组进行多次遍历,每次均比较相邻的两个数,如果前一个比后一个大,则交换这两个数.经过第一次遍历之后,最大的数就在最右侧了:第二次遍历之后,第二大的数就在右数第二个位置了:以此类推. 复制代码 代码如下:

  • Java实现八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序等

    本文实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 .快速排序.归并排序.堆排序和LST基数排序 首先是EightAlgorithms.java文件,代码如下: import java.util.Arrays; /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ public class EightAlgorithms { //插入排序:时间复杂度o(n^2) p

  • JavaScript 冒泡排序和选择排序的实现代码

    废话不多说了,直接给大家贴代码了,具体代码如下所述: var array = [1,2,3,4,5]; // ---> 服务 //效率 ---> 针对一个有序的数组 效率最高 //标志 true false for(var j = 0; j < array.length - 1;j++ ){ //- j 每次排序完成之后 后面减少比较的次数 var isTrue = true; //如果数组本身就是升序,则直接输出 for(var i = 0; i < array.length -

  • C++实现八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序等

    本文实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 .快速排序.归并排序.堆排序和LST基数排序 首先是算法实现文件Sort.h,代码如下: /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ #include <iostream> template<class T> void swap_value(T &a, T &b) { T t

  • JS排序算法之冒泡排序,选择排序与插入排序实例分析

    本文实例讲述了JS排序算法之冒泡排序,选择排序与插入排序.分享给大家供大家参考,具体如下: 冒泡排序: 对数组的中的数据,依次比较相邻两数的大小. 如果前面的数据大于后面的数据,就交换这两个数. 时间复杂度O(n^2) function bubble(array){ var temp; for(var i=0; i<arr.length; i++){ for(var j=0; j<arr.length; j++){ if(arr[j]>arr[j+1]){ temp = arr[j+1]

  • C++冒泡排序与选择排序详解

    目录  一.冒泡排序 1.概念  2.图解 3.代码的思路 4.代码例子  二.选择排序 1.概念 2.图解 3.代码的思路 总结  一.冒泡排序 1.概念 冒泡排序这种排序方法其实关键词就在于冒泡两个字,顾名思义就是数字不断比较然后最大的突出来,也就是说把相邻的两个数字两两比较,当一个数字大于右侧相邻的数字时,交换他们的位置,当一个数字和他右侧的数字小于或等于的时候,不交换.  2.图解 关于冒泡排序我自己画了一幅图来描述他的一轮过程 这里我举了五个无序的数{7,3,6,5,4}  由此可看出

  • c语言冒泡排序和选择排序的使用代码

    目录 1.冒泡排序 2.选择排序 区别 总结 1.冒泡排序 冒泡排序将一个列表中的两个元素进行比较,并将最小的元素交换到顶部.两个元素中较小的会冒到顶部,而较大的会沉到底部,该过程将被重复执行,直到所有元素都被排序. 冒泡排序示意图 以如图所示的冒泡排序为例,每次比较相邻的两个值,值小的交换到前面,每轮结束后值最大的数交换到了最后.第一轮需要比较4次:第二轮需要比较3次:第三轮需要比较2次:第四轮需要比较1次. 那么如何用二重循环将5个数排序呢?5个数存放在一维数组中,外层循环控制比较多少轮,循

随机推荐