算法-02-排序-冒泡插入选择排序

一般最经典的、最常用的:冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序。那么我们如何分析一个"排序算法"呢?

1-分析排序算法要点

时间复杂度:具体是指最好情况、最坏情况、平均情况下的时间复杂度。
时间复杂度的系数,常数,低阶:对于排序规模很小的数据,在对同一阶时间复杂度的排序算法性能对比的时候,我们就要把系数、常数、低阶也考虑进来。
比较次数和交换次数:在分析排序算法的执行效率的时候,应该把比较次数和交换(或移动)次数也考虑进去。
排序算法的内存消耗:算法的内存消耗可以通过空间复杂度来衡量,排序算法也不例外;原地排序(Sorted in place)算法,就是特指空间复杂度是O(1)的排序算法。。
排序算法的稳定性:如果待排序的序列中存在值相等的元素,经过排序之后,相等元素之间原有的先后顺序不变。

2-冒泡-插入-选择排序

2.1-冒泡排序(Bubble Sort)

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置,重复n次,就完成了n个数据的排序工作。

工作原理:原始数据14,15,16,13,12,11,冒泡排序的经过如下图:

我们展示一下第1轮冒泡出16的过程:

下图是多轮冒泡的结果

Java代码体现,为了减少不必要的排序次数,我们如果发现没有数据交换,就可以结束排序,这样可以减少循环次数。

java 复制代码
@Slf4j
public class BubbleSort {

    public static void main(String[] args) {
        int[] arr={10,8,9,15,23,6,24};
        sort(arr);
    }

    public static void sort(int[] arr) {
        int length = arr.length;
        if (length <= 1) {
            return;
        }
        for (int i = 0; i < length; i++) {
            boolean flag = false;
            for (int j = 0; j < length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if(! flag){
                break;
            }
        }
        log.info("排序后数组arr={}",arr);
    }
}

(1)冒泡的过程只涉及相邻数据的交换操作,只需要常量级的临时空间,所以它的空间复杂度为O(1),是一个原地排序算法。

(2)在冒泡排序中,只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性,当有相邻的两个元素大小相等的时候,我们不做交换,相同大小的数据在排序前后不会改变顺序,所以冒泡排序是稳定的排序算法。

(3)最好情况下,要排序的数据已经是有序的了,我们只需要进行一次冒泡操作,就可以结束了,所以最好情况时间复杂度是O(n)。而最坏的情况是,要排序的数据刚好是倒序排列的,我们需要进行n次冒泡操作,所以最坏情况时间复杂度为O(n^2)。平均情况下的时间复杂度就是O(n^2)。

2.2-插入排序(Insertion Sort)

插入算法的核心思想是取未排序区间中的元素,在已排序区间中找到合适的插入位置将其插入,并保证已排序区间数据一直有序。重复这个过程,直到未排序区间中元素为空,算法结束。

原始数组:14,15,16,13,12,11;排序的流程图如下:

java 复制代码
@Slf4j
public class InsertionSort {
    public static void main(String[] args) {
        int[] arr = {10, 8, 9, 15, 23, 6, 24};
        sort(arr);
    }

    public static void sort(int[] arr) {
        int length = arr.length;
        if (length <= 1) {
            return;
        }
        for (int i = 1; i < length; i++) {
            int value = arr[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (arr[j] > value) {
                    arr[j + 1] = arr[j];
                } else {
                    break;
                }
            }
            arr[j+1]=value;
        }
        log.info("排序后数组arr={}", arr);
    }
}

(1)从实现过程可以很明显地看出,插入排序算法的运行并不需要额外的存储空间,所以空间复杂度是O(1),也就是说,这是一个原地排序算法。

(2)在插入排序中,对于值相同的元素,我们可以选择将后面出现的元素,插入到前面出现元素的后面,这样就可以保持原有的前后顺序不变,所以插入排序是稳定的排序算法。

(3)最好是时间复杂度为O(n),最坏情况时间复杂度为O(n^2),平均时间复杂度为O(n^2)。

2.3-选择排序(Selection Sort)

选择排序算法的实现思路有点类似插入排序,也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素,将最小元素放到已排序区间的第一个位置。

java 复制代码
@Slf4j
public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {10, 8, 9, 15, 23, 6, 24};
        sort(arr);
    }

    public static void sort(int[] arr) {
        int length = arr.length;
        if (length <= 1) {
            return;
        }
        int minIndex;//最小值元素索引
        int min;//最小值元素
        for (int i = 0; i < arr.length - 1; i++) {
            minIndex = i;
            min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    minIndex = j;
                }
            }
            //交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
        log.info("排序后数组arr={}", arr);
    }
}

(1)选择排序空间复杂度为O(1),是一种原地排序算法。

(2)选择排序是一种不稳定的排序算法。选择排序每次都要找剩余未排序元素中的最小值,并和前面的元素交换位置,这样破坏了稳定性。

(3)选择排序的最好情况时间复杂度、最坏情况和平均情况时间复杂度都为O(n^2)。

3-小结

冒泡,插入,选择排序的平均时间复杂度都是O(n^2),三种排序算法对比结果如下图:

冒泡排序和插入排序的时间复杂度都是O(n2),都是原地排序算法,插入排序要比冒泡排序性能更好。因为冒泡排序的数据交换要比插入排序的数据移动要复杂,冒泡排序需要3个赋值操作,而插入排序只需要1个,冒泡排序耗费更多的时间单位。

相关推荐
小码农<^_^>13 分钟前
优选算法精品课--滑动窗口算法(一)
算法
羊小猪~~15 分钟前
神经网络基础--什么是正向传播??什么是方向传播??
人工智能·pytorch·python·深度学习·神经网络·算法·机器学习
软工菜鸡40 分钟前
预训练语言模型BERT——PaddleNLP中的预训练模型
大数据·人工智能·深度学习·算法·语言模型·自然语言处理·bert
南宫生43 分钟前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
AI视觉网奇1 小时前
sklearn 安装使用笔记
人工智能·算法·sklearn
JingHongB1 小时前
代码随想录算法训练营Day55 | 图论理论基础、深度优先搜索理论基础、卡玛网 98.所有可达路径、797. 所有可能的路径、广度优先搜索理论基础
算法·深度优先·图论
weixin_432702262 小时前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习2 小时前
day52 图论章节刷题Part04(110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长 )
算法·深度优先·图论
Repeat7152 小时前
图论基础--孤岛系列
算法·深度优先·广度优先·图论基础
小冉在学习2 小时前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论