排序算法-简单排序

最新推荐文章于 2022-04-12 21:46:27 发布
最新推荐文章于 2022-04-12 21:46:27 发布
阅读量156 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxx11144/article/details/116567248
版权

排序算法-简单排序

插入排序

算法解释

插入排序(InsertionSort)，一般也被称为直接插入排序。

插入排序的工作方式非常像人们排序一手扑克牌一样。每次拾起新牌后，人们习惯按照升降序顺序将新牌插入到指定的位置。实际上，每次拿到新牌，大脑会将新牌和手中的已经排好顺序的牌进行比较。只不过大脑运行也很快以至于好像没有进行运算的感觉。

插入排序

核心思想

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

算法模拟

  1. 箭头指向的元素为待排序元素；
  2. 蓝色选中区域内的元素为已经排好序的元素组；
  3. 箭头指向的元素需要和蓝色选中区域内的元素从右到左逐个进行比较，如果蓝色区域的元素比待排序元素大，则交换位置，直到在蓝色选中区域内找到比待排序元素小为止。

在这里插入图片描述

程序实现

package com.skystep.algorithm;

public class Insertion {

    public static void sortAsc(Comparable[] comparables) {
        int len = comparables.length;

        for (int i = 1; i < len; i++) {
            for (int j = i; j > 0; j--) {
                if (compare(comparables[j], comparables[j-1])) {
                    break;
                }
                change(comparables, j, j-1);
            }
        }
    }

    public static void sortDesc(Comparable[] comparables) {
        int len = comparables.length;
        for (int i = 1; i < len; i++) {
            for (int j = i; j > 0; j--) {
                if (!compare(comparables[j], comparables[j-1])) {
                    break;
                }
                change(comparables, j, j-1);
            }
        }
    }


    public static void change(Comparable[] comparables, int x, int y) {
        Comparable tmp = comparables[x];
        comparables[x] = comparables[y];
        comparables[y] = tmp;
    }

    public static boolean compare(Comparable source, Comparable target) {
        return source.compareTo(target) >= 0;
    }

    public static void main(String[] args) {
        Integer[] arr = {1, 2, 4, 3, 6, 5};
        Insertion.sortAsc(arr);
        for (Integer integer : arr) {
            System.out.print(integer);
            System.out.print(" ");
        }
        System.out.println();

        Insertion.sortDesc(arr);
        for (Integer integer : arr) {
            System.out.print(integer);
            System.out.print(" ");
        }
        System.out.println();

        Student s1 = new Student(10, "s1");
        Student s2 = new Student(13, "s2");
        Student s3 = new Student(12, "s3");
        Student s4 = new Student(17, "s4");
        Student s5 = new Student(14, "s5");
        Student[] students = {s1, s2, s3, s4, s5};

        Insertion.sortDesc(students);
        for (Student student : students) {
            System.out.println("age:" + student.getAge() + "," + "name:" + student.getName());
        }
        System.out.println();

        Insertion.sortAsc(students);
        for (Student student : students) {
            System.out.println("age:" + student.getAge() + "," + "name:" + student.getName());
        }
        System.out.println();
    }
}

适用说明

插入排序的平均时间复杂度是 O(n^2)，空间复杂度为常数阶 O(1)，具体时间复杂度和数组的有序性也是有关联的。对于少量元素的排序，它是一个有效的算法。

插入排序中，当待排序数组是有序时，是最优的情况，只需当前数跟前一个数比较一下就可以了，这时一共需要比较 N-1 次，时间复杂度为 O(N)。最坏的情况是待排序数组是逆序的，此时需要比较次数最多，最坏的情况是 O(n^2)。

冒泡排序

算法解释

冒泡排序，类似于水中冒泡，较大的数沉下去，较小的数慢慢冒起来，假设从小到大，即为较大的数慢慢往后排，较小的数慢慢往前排。对于待排序的数据，每一趟相邻的元素的对比，最后都有一个最值元素移动列末尾。
冒泡排序

核心思想

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

算法模拟

  1. 选中的元素为每一趟要进行排序的元素，比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置，每经一趟比较，都有一个最值排到最后，标识为红色；
  2. 循环第一步的直到选中的元素个数为1，则完成整个排序过程。
    在这里插入图片描述

程序实现

package com.skystep.algorithm;

public class Bubble {

    public static void sortAsc(Comparable[] comparables) {
        int len = comparables.length;

        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - i - 1; j++) {
                if (compare(comparables[j], comparables[j + 1])) {
                    change(comparables, j, j + 1);
                }
            }
        }
    }

    public static void sortDesc(Comparable[] comparables) {
        int len = comparables.length;

        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - i - 1; j++) {
                if (!compare(comparables[j], comparables[j + 1])) {
                    change(comparables, j, j + 1);
                }
            }
        }
    }

    public static void change(Comparable[] comparables, int x, int y) {
        Comparable tmp = comparables[x];
        comparables[x] = comparables[y];
        comparables[y] = tmp;
    }

    public static boolean compare(Comparable source, Comparable target) {
        return source.compareTo(target) >= 0;
    }


    public static void main(String[] args) {
        Integer[] arr = {1, 2, 4, 3, 6, 5};
        Bubble.sortDesc(arr);
        for (Integer integer : arr) {
            System.out.print(integer);
            System.out.print(" ");
        }
        System.out.println();

        Bubble.sortAsc(arr);
        for (Integer integer : arr) {
            System.out.print(integer);
            System.out.print(" ");
        }
        System.out.println();

        Student s1 = new Student(10, "s1");
        Student s2 = new Student(13, "s2");
        Student s3 = new Student(12, "s3");
        Student s4 = new Student(17, "s4");
        Student s5 = new Student(14, "s5");
        Student[] students = {s1, s2, s3, s4, s5};

        Bubble.sortDesc(students);
        for (Student student : students) {
            System.out.println("age:" + student.getAge() + "," + "name:" + student.getName());
        }
        System.out.println();

        Bubble.sortAsc(students);
        for (Student student : students) {
            System.out.println("age:" + student.getAge() + "," + "name:" + student.getName());
        }
        System.out.println();
    }
}

适用说明

冒泡法排序的平均时间复杂度是 O(n^2)，空间复杂度为常数阶 O(1)，具体时间复杂度和数组的有序性也是有关联的。对于少量元素的排序，它是一个有效的算法。

冒泡法排序的最好情况是数据元素集合已经全部排好序，这是循环n-1次每次没有交换动作而退出，因此，冒泡排序的最好情况的时间复杂是是O(n);冒泡排序算法的最坏情况是数据元素集合全部逆序存放，这时循环n-1次 比较次数你n(n-1)/2 和交换移动次数 3n(n-1)/2，因此冒泡排序算法最坏情况时间复杂度为O(n^2)。

选择排序

算法解释

选择排序是一种简单直观的排序算法。一旦涉及排序。大多数实现者首先想到的是选择排序。该排序每趟都假想首个元素为最值，和剩余的元素进行比较，如果发现有比该值小的则交互下标，直到该趟结束，则交换下标对应的值。

核心思想

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

算法模拟

在这里插入图片描述

程序实现

package com.skystep.algorithm;

public class Selection {

    public static void sortAsc(Comparable[] comparables) {
        int len = comparables.length;
        for (int i = 0; i < len - 1; i++) {
            int min = i;
            for (int j = i + 1; j < len; j++) {
                if (compare(comparables[min], comparables[j])) {
                    min = j;
                }
            }
            change(comparables, i, min);
        }
    }

    public static void sortDesc(Comparable[] comparables) {
        int len = comparables.length;
        for (int i = 0; i < len - 1; i++) {
            int max = i;
            for (int j = i + 1; j < len; j++) {
                if (!compare(comparables[max], comparables[j])) {
                    max = j;
                }
            }
            change(comparables, i, max);
        }
    }


    public static void change(Comparable[] comparables, int x, int y) {
        Comparable tmp = comparables[x];
        comparables[x] = comparables[y];
        comparables[y] = tmp;
    }

    public static boolean compare(Comparable source, Comparable target) {
        return source.compareTo(target) >= 0;
    }

    public static void main(String[] args) {
        Integer[] arr = {1, 2, 4, 3, 6, 5};
        Selection.sortDesc(arr);
        for (Integer integer : arr) {
            System.out.print(integer);
            System.out.print(" ");
        }
        System.out.println();

        Selection.sortAsc(arr);
        for (Integer integer : arr) {
            System.out.print(integer);
            System.out.print(" ");
        }
        System.out.println();

        Student s1 = new Student(10, "s1");
        Student s2 = new Student(13, "s2");
        Student s3 = new Student(12, "s3");
        Student s4 = new Student(17, "s4");
        Student s5 = new Student(14, "s5");
        Student[] students = {s1, s2, s3, s4, s5};
        Selection.sortDesc(students);
        
        for (Student student : students) {
            System.out.println("age:" + student.getAge() + "," + "name:" + student.getName());
        }
        System.out.println();
        Selection.sortAsc(students);
        for (Student student : students) {
            System.out.println("age:" + student.getAge() + "," + "name:" + student.getName());
        }
        System.out.println();
    }
}

适用说明

选择排序的平均时间复杂度是 O(n^2)，空间复杂度为常数阶 O(1)，具体时间复杂度和数组的有序性也是有关联的。对于少量元素的排序，它是一个有效的算法。

代码地址

https://gitee.com/yaomianwei2020/study

YaoSirComeOn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++排序算法-冒泡排序
11-08
冒泡排序
Java二维数组根据某一列进行排序
m0_43374604的博客
07-06 1363
有时可能会遇到二维数组根据某一列进行排序，这里使用的方法是重写Arrays.sort()方法 int intervals[][] = {{2,6},{1,3},{8,10},{15,18}}; System.out.println("排序前"); for (int i = 0; i < intervals.length; i++){ for (int j = 0; j < 2; j++){ System.out.print(interval
java_时间复杂度较小的排序方法_时间复杂度O(N)
qq_53261858的博客
02-25 1222
思路来源于一个算法题。有点懒就不怎么改动代码啦。可根据需要自行改动。 给定序列 (a1, a2, · · · , an) = (1, 2, · · · , n)，即 ai = i。 小蓝将对这个序列进行 m 次操作，每次可能是将 a1, a2, · · · , aqi 降序排列，或者将 aqi , aqi+1, · · · , an 升序排列。 请求出操作完成后的序列。 以下代码可用于对数组的指定位置区间进行升序或者降序。 主函数 n：表示要排序的元素，如n=3，数组元素就是1，2，3 m：表示要执行升
几种简单的排序算法
hulin的博客
12-09 3016
几种简单的排序算法分享
插入排序
一个IT人的技术成长历程。创造未来的行为就发生在今天，没有明天的目标，今天的行动就是重复昨天的事情。
02-24 355
插入排序：有待排序数组A，任意指定A中某一位置作为元素的插入位置B。此时，假设B位置左端的所有元素都是有序的，记录下B位置的元素ValueB，将ValueB与其左端的有序元素进行比较，如果ValueB左端的元素大于或等于ValueB，则将其后移一位，最后在后移空出的位置将ValueB插入。重复以上步骤，直到数组中的最后一个元素，排序结束。 package blog.csdn.net.zhaik...
排序算法整理
qq_42665165的博客
10-24 246
时间复杂度 一 冒泡排序 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 1算法步骤 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，
排序算法--比较类排序
06-06
我写的一个内排序的博客算法的一个总结,全部代码在这个里面,需要的就看看吧!!还需要什么请联系我,我有就发!!
FPGA并行快速排序算法-位宽可设
11-24
只需两个时钟即可输出12个数据的排序结果，内容简单易懂
C语言排序算法---冒泡排序法
03-23
在STM8S003单片机上实现数组排序，用3种冒泡排序法对数组进行排序，并通过串口打印排序过程。
详解Java常用排序算法-基数排序
最新发布
08-26
详解Java常用排序算法-基数排序
无序数组排序
11-13 2751
有1,2,..一直到n的无序数组，求排序算法，并且要求时间复杂度为O(n),空间复杂度为O(1),使用交换，而且一次只能交换两个数#include<iostream> using namespace std; int main() { int arr[10]={10,6,9,5,2,8,4,7,1,3}; int len=sizeof(arr)/sizeof(int); in
排序算法之快速排序（C语言）
qq_35600620的博客
03-28 1657
一、原理讲解 快速排序的核心思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 简单的说法，就是设置一个基准，将无序数组的数据分隔成两部分，基准左边的数据都小于基准，基准右边的数据都大于基准。然后不断设置基准与参与排序的数据个数进行排序，...
时间复杂度较低排序算法c语言,JS排序算法总结：（六）归并排序
weixin_39627697的博客
05-24 496
目的：掌握 归并排序的基本思想与过程、代码实现、时间复杂度1、基本思想与过程：先递归的分解数列，再合并数列(分治思想的典型应用)(1)将一个数组拆成A、B两个小组，两个小组继续拆，直到每个小组只有一个元素为止。(2)按照拆分过程逐步合并小组，由于各小组初始只有一个元素，可以看做小组内部是有序的，合并小组可以被看做是合并两个有序数组的过程。(3)对左右两个小数列重复第二步，直至各区间只有1个数。下...
定义一个无序数组，做选择排序
qq_55910177的博客
04-12 661
思路是： 循环查找从当前位置开始到数组的最后一位中最小的数值，如果当前位置大于下一位，则将下一位当作最小，依次往后查找，直到最后一位，然后将下标返回给临时变量minPosition； 根据返回的最小位置下标，取出最小元素，并将当前位置的元素取出，将最小元素放到当前位置，将当前位置的oid元素放到最小元素原来所在的位置； 这样就将数组中最小元素放到了数组的最前面，依次执行。 /** * 定义一个无序数组，做选择排序 */ public class...
用python编写排序算法
dengchou2870的博客
08-05 323
交换排序 ＝＝＝ 冒泡排序，快速排序 插入排序 ＝＝＝直接插入排序，希尔排序 选择排序 ＝＝＝ 简单选择排序，堆排序 归并排序 基数排序 冒泡排序 要点 冒泡排序是一种交换排序。 什么是交换排序呢？ 交换排序：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。 原理：比较两个相邻的元素，将值大的元素交换到前面。 算法思想 它重复地...
快速排序 C语言版
qq_45637053的博客
12-05 350
普通的排序方法有：冒泡排序法，顺序比较法，选择排序法 等等，这些排序大同小异，思维简单，容易上手，但是他们共同的缺点是：时间复杂度过高，皆为O（n*n）,容易超时，在这种情况之下，快速排序应运而生： 在相同数据量的情况下，快速排序的平均时间复杂度为O(NlogN) 先上代码： #include<stdio.h> #define m 5 int a[m+1]; void quickso...
排序算法&算法时间复杂度
afr467的博客
06-12 1048
1、排序 排序分类： 1）内部排序： 值将需要处理的所有数据都加载到内部存储器中进行排序。 2）外部排序： 数据量大，无法全部加载到内存中，需要借助外部存储进行排序。 2、排算法时间复杂度 2.1方法： 1）事后统计法 这种方式要在同一台计算机的相同状态下运行，才能比较哪个算法速度更快并且所得时间的统计量依赖于计算机的硬件、软件等环境因素。 2）事前估算法 通过分析某个算法的时间复杂度来判断哪个算法更优。 2.2时间频度 一个算法花费的时间与算法中语句的执行次数成正比，哪个算法中语句执行次数多花费时间就多
C++——使用简单数组实现排序算法，并进行比较
芋头圆生煎的博客
03-11 2458
题目： 使用简单数组实现下面各种排序算法，并进行比较。 排序算法： 1、插入排序 2、希尔排序 3、冒泡排序 4、快速排序 5、简单选择排序 6、堆排序（选作） 7、归并排序（选作） 8、基数排序（选作） 9、其他 要求： 1、测试数据分成三类：正序、逆序、随机数据 2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。 3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作） 4、对2和3的结果进行分析，验证上述各种算法的时间复杂度 编写测试m
常见排序算法程序设计
zhao_hong_liang的博客
04-05 2569
0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 . 稳定：如果a原本在b前面，而a...
线段排序算法-C++
08-09
以下是一个简单的线段排序算法的示例代码，使用 C++ 实现： ```cpp #include #include #include struct Segment { int start; int end; }; bool compareSegments(const Segment& seg1, const Segment& seg2)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值