常见的排序算法详细分析与实现

最新推荐文章于 2024-01-06 23:08:55 发布
最新推荐文章于 2024-01-06 23:08:55 发布
阅读量187 收藏
点赞数 1
分类专栏： java基础 算法 文章标签： 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xdkb159/article/details/80857335
版权
  1. 冒泡排序
    • 外层循环n-1轮
    • 每轮循环都比较相邻位置的两个值，每轮循环比较次数都依次递减
    • 这样，每次循环都会把大的数移到后面
    效果如下： 
    原始数据：8 1 4 9 0 3 5 2 7 6

1 4 8 0 3 5 2 7 6 9 
1 4 0 3 5 2 7 6 8 9 
1 0 3 4 2 5 6 7 8 9 
0 1 3 2 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 9 
1 4 0 3 5 2 7 6 8 9 
1 0 3 4 2 5 6 7 8 9 
0 1 3 2 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9
  2. 选择排序
    1. 外层循环n-1轮
    2. 每次循环都和后面所有数比较，选出最小值，每轮循环比较次数也是依次递减
    3. 最后交换开始值和最小值的位置，所以交换次数固定
    效果如下： 
    原始数据：8 1 4 9 0 3 5 2 7 6

0 1 4 9 8 3 5 2 7 6 
0 1 4 9 8 3 5 2 7 6 
0 1 2 9 8 3 5 4 7 6 
0 1 2 3 8 9 5 4 7 6 
0 1 2 3 4 9 5 8 7 6 
0 1 2 3 4 5 9 8 7 6 
0 1 2 3 4 5 6 8 7 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 0 1 4 9 8 3 5 2 7 6 
0 1 4 9 8 3 5 2 7 6 
0 1 2 9 8 3 5 4 7 6 
0 1 2 3 8 9 5 4 7 6 
0 1 2 3 4 9 5 8 7 6 
0 1 2 3 4 5 9 8 7 6 
0 1 2 3 4 5 6 8 7 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9
  3. 插入排序
    1. 外层循环n-1轮
    2. 每轮循环当前值与前一个值比较，如果当前值小于前一个值，前一个值后移一位，依次向前比较
    3. 直到当前值大于前一个值，插入在它后面
    效果如下： 
     
    原始数据：8 1 4 9 0 3 5 2 7 6
1 8 4 9 0 3 5 2 7 6 
1 4 8 9 0 3 5 2 7 6 
1 4 8 9 0 3 5 2 7 6 
0 1 4 8 9 3 5 2 7 6 
0 1 3 4 8 9 5 2 7 6 
0 1 3 4 5 8 9 2 7 6 
0 1 2 3 4 5 8 9 7 6 
0 1 2 3 4 5 7 8 9 6 
0 1 2 3 4 5 6 7 8 9

1 8 4 9 0 3 5 2 7 6 
1 4 8 9 0 3 5 2 7 6 
1 4 8 9 0 3 5 2 7 6 
0 1 4 8 9 3 5 2 7 6 
0 1 3 4 8 9 5 2 7 6 
0 1 3 4 5 8 9 2 7 6 
0 1 2 3 4 5 8 9 7 6 
0 1 2 3 4 5 7 8 9 6 
0 1 2 3 4 5 6 7 8 9
  4. 快速排序
    1. 采用分区递归的方法排序，直到所有最小分区大小为一，递归返回
    2. 每轮首先选取分区的第一个值作为基准数x，通过两个哨兵可以确定x的位置（基准数x在正确排序中的位置），并保证x的左边都是小于它的数，右边都是大于它的数
    3. 首先，哨兵j从分区的最右边向左移动，找到小于x的数，停下，把该数的放到x的位置或前面哨兵i停下的位置，然后哨兵i开始移动；
    4. 哨兵i从分区的最左边开始想右边移动，找到大于基准数x的数，停下，把该数放到前面哨兵j停下的位置，然后哨兵j又开始移动；
    5. 一直循环3,4步骤，知道哨兵i和哨兵j相遇，这个位置就是基准数x在正确排序中的位置，把x放在该位置，一轮循环完成；
    6. 基准数x前面的数为一个分区，后面的数为一个分区，分别进行递归调用，执行前面的步骤。
    效果如下： 
    原始数据：8 1 4 9 0 3 5 2 7 6

第一轮 基准数为8
6 1 4 9 0 3 5 2 7 6 哨兵j从6开始向左移动
6 1 4 9 0 3 5 2 7 9 哨兵i从1开始想右移动
6 1 4 7 0 3 5 2 7 9 
6 1 4 7 0 3 5 2 7 9 
6 1 4 7 0 3 5 2 7 9 
2 1 4 7 0 3 5 2 8 9 确定8的位置
第二轮 基准数2, 只有8左边的分区进行排序
2 1 4 7 0 3 5 7 8 9 确定9的位置
2 1 4 5 0 3 5 7 8 9 
2 1 4 5 0 3 5 7 8 9 
2 1 4 5 0 3 5 7 8 9 
0 1 4 5 0 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 2 5 4 3 6 7 8 9 确定2的位置
第三轮 分区0 1 基准数0 
0 1 2 5 4 3 6 7 8 9 确定1的位置
0 1 2 5 4 3 6 7 8 9 确定0的位置
第四轮 分区 5 4 3 6 7 基准数5
0 1 2 5 4 3 6 7 8 9 
0 1 2 3 4 3 6 7 8 9 
0 1 2 3 4 3 6 7 8 9 
0 1 2 3 4 3 6 7 8 9 
0 1 2 3 4 5 6 7 8 9  确定5的位置
第五轮 分区3 4 基准数3
0 1 2 3 4 5 6 7 8 9 确定4的位置
0 1 2 3 4 5 6 7 8 9 确定3的位置
第六轮 分区 6 7 基准数6
0 1 2 3 4 5 6 7 8 9 确定7的位置
0 1 2 3 4 5 6 7 8 9 确定6的位置
0 1 2 3 4 5 6 7 8 9 

6 1 4 9 0 3 5 2 7 6 哨兵j从6开始向左移动
6 1 4 9 0 3 5 2 7 9 哨兵i从1开始想右移动
6 1 4 7 0 3 5 2 7 9 
6 1 4 7 0 3 5 2 7 9 
6 1 4 7 0 3 5 2 7 9 
2 1 4 7 0 3 5 2 8 9 确定8的位置
第二轮 基准数2, 只有8左边的分区进行排序
2 1 4 7 0 3 5 7 8 9 确定9的位置
2 1 4 5 0 3 5 7 8 9 
2 1 4 5 0 3 5 7 8 9 
2 1 4 5 0 3 5 7 8 9 
0 1 4 5 0 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 4 5 4 3 6 7 8 9 
0 1 2 5 4 3 6 7 8 9 确定2的位置
第三轮 分区0 1 基准数0 
0 1 2 5 4 3 6 7 8 9 确定1的位置
0 1 2 5 4 3 6 7 8 9 确定0的位置
第四轮 分区 5 4 3 6 7 基准数5
0 1 2 5 4 3 6 7 8 9 
0 1 2 3 4 3 6 7 8 9 
0 1 2 3 4 3 6 7 8 9 
0 1 2 3 4 3 6 7 8 9 
0 1 2 3 4 5 6 7 8 9  确定5的位置
第五轮 分区3 4 基准数3
0 1 2 3 4 5 6 7 8 9 确定4的位置
0 1 2 3 4 5 6 7 8 9 确定3的位置
第六轮 分区 6 7 基准数6
0 1 2 3 4 5 6 7 8 9 确定7的位置
0 1 2 3 4 5 6 7 8 9 确定6的位置
0 1 2 3 4 5 6 7 8 9

 


  实现代码：

 

 

 

package test;

import java.util.Random;

/**
 * 排序算法
 */
public class SortTest {
    static int b = 0;
    static int h = 0;

    public static void main(String[] args) {
        Random random = new Random();
        int[] nums = new int[10000];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = random.nextInt(nums.length);
        }
        printArr(nums);

        printArr(maopao(nums.clone()));

        printArr(xuanze(nums.clone()));

        printArr(charu(nums.clone()));

        printArr(quickSort(nums));
    }

    /**
     * 冒泡排序
     * 1、外层循环n-1轮
     * 2、内层循环比较相邻的两个值
     * 3、如果前一个大于后一个，则交换两个值的位置
     *
     * @param nums
     * @return
     */
    public static int[] maopao(int[] nums) {
        long start = System.currentTimeMillis();
        int bj = 0;
        int jh = 0;
        for (int j = 0; j < nums.length; j++) {
            for (int i = 0; i < nums.length - j - 1; i++) {
                bj++;
                if (nums[i] > nums[i + 1]) {
                    jh++;
                    int tmp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = tmp;
                }
            }
        }
        System.out.println("冒泡排序------耗时: " + (System.currentTimeMillis() - start) + "ms, " + "比较次数: " + bj + ", 交换次数: " + jh);
        return nums;
    }

    /**
     * 选择排序
     * 1、外层循环n-1轮
     * 2、每次循环选出最小的值
     * 3、最后交换开始值和最小值的位置，所以交换次数固定
     *
     * @param nums
     * @return
     */
    public static int[] xuanze(int[] nums) {
        long start = System.currentTimeMillis();
        int bj = 0;
        int jh = 0;
        int mix, tmp;
        for (int j = 0; j < nums.length; j++) {
            mix = j;
            for (int i = j + 1; i < nums.length; i++) {
                bj++;
                if (nums[mix] > nums[i]) {
                    mix = i;
                }
            }
            jh++;//每轮比较找出最小的数，交换一次
            tmp = nums[j];
            nums[j] = nums[mix];
            nums[mix] = tmp;
        }
        System.out.println("选择排序------耗时: " + (System.currentTimeMillis() - start) + "ms, " + "比较次数: " + bj + ", 交换次数: " + jh);
        return nums;
    }

    /**
     * 插入排序
     * 1、外层循环n-1轮
     * 2、每轮循环当前值与前一个值比较，如果当前值小于前一个值，前一个值后移一位，依次向前比较
     * 3、直到当前值大于前一个值，插入在它后面
     *
     * @param nums
     * @return
     */
    public static int[] charu(int[] nums) {
        long start = System.currentTimeMillis();
        int bj = 0;
        int jh = 0;
        int preIndex, current = 0;
        for (int i = 1; i < nums.length; i++) {
            preIndex = i - 1;
            current = nums[i];
            while (preIndex >= 0 && nums[preIndex] > current) {//前一个值大于当前值，
                bj++;
                jh++;
                nums[preIndex + 1] = nums[preIndex];//前一个值移到当前值位置
                preIndex--;//当前值再与前前一个值比较
            }
            nums[preIndex + 1] = current;//当前值大于preIndex处的值，插入在它后面
        }
        System.out.println("插入排序------耗时: " + (System.currentTimeMillis() - start) + "ms, " + "比较次数: " + bj + ", 交换次数: " + jh);
        return nums;
    }

    /**
     * 快速排序
     *
     * @param nums
     * @return
     */
    public static int[] quickSort(int[] nums) {
        long start = System.currentTimeMillis();
        nums = kuaisu(nums, 0, nums.length - 1);
        System.out.println("快速排序------耗时: " + (System.currentTimeMillis() - start) + "ms, " + "比较次数: " + b + ", 交换次数: " + h);
        return nums;
    }

    public static int[] kuaisu(int[] nums, int l, int r) {
        if (l > r) {
            // 每次递归排序分区大小为1时，返回
            return nums;
        }
        // 哨兵i向右移动，哨兵j向左移动，基准数x
        int i = l, j = r, x = nums[l];//每次都选择第一个数为基准数
        while (i != j) {
            while (i < j && nums[j] >= x) {
                b++;
                j--;//哨兵j从右边向左找第一个小于x的数
            }
            nums[i] = nums[j];//把小于x的数放在基准数x的位置，或已复制到右边的大于基准数的位置
            while (i < j && nums[i] <= x) {
                b++;
                i++;//哨兵i从左边向右找第一个大于x的数
            }
            nums[j] = nums[i];//把大于x的数放到已复制到左边的小于x的数的位置
            h++;
        }
        nums[i] = x;//完成一轮循环，确定了一个基准数x的位置
        kuaisu(nums, l, i - 1);
        kuaisu(nums, i + 1, r);
        return nums;
    }

    public static void printArr(int[] nums) {
        for (int i : nums) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

 

 

 

  排序10000个随机顺序数的结果：

冒泡排序------耗时: 203ms, 比较次数: 49995000, 交换次数: 25069325

选择排序------耗时: 93ms, 比较次数: 49995000, 交换次数: 10000

插入排序------耗时: 31ms, 比较次数: 25069325, 交换次数: 25069325

快速排序------耗时: 0ms, 比较次数: 149399, 交换次数: 31226

 

江凌
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
经典排序算法分析与实现
slow_sparrow的博客
03-09 318
经典排序算法分析与实现算法一、常见排序算法1.comparable和comparator2.约定3.选择排序算法4.冒泡排序算法5.插入排序算法6.希尔排序算法7.归并排序算法7.1 自顶向上归并排序7.2 自底向上归并排序8.快速排序算法8.1 基本算法8.2 性能分析8.3 算法改进8.3.1 切换到插入排序8.3.2 三数取中算法8.3.3 三向切分算法8.4 基于切分的快速选择算法9.堆排序10.上述排序算法的比较二、JDK自带的DualPivotQuickSort三、学习参考： 算法 一、常见排序
常见的排序算法分析
gaosaixing的博客
03-10 386
1、冒泡排序。冒泡排序执行的时间取决于比较的趟数，在最好的情况下，待排序的记录是正序，算法只执行一趟，进行了n-1次关键码的比较，不需要移动记录，时间复杂度是O(N);最坏的情况下，是倒序，每次比较只有一个最大的记录被交换到最终的位置，故算法执行了n-1趟，每次比较的次数是n-i,关键码比较的次数是n(n-1)/2.。平均情况的时间复杂度与最坏的情况是同一个数量级的。空间复杂度o(1).  它是稳...
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
常见排序算法及其稳定性分析
最新发布
稻草人敲代码的博客
01-06 1295
排序算法可以说是每一个程序员在学习数据结构和算法时必须要掌握的知识点，同样也是面试过程中可能会遇到的问题，在早些年甚至还会考冒泡排序。由此可见呢，掌握一些常见的排序算法是一个程序员的基本素养。虽然现在的语言标准库里都有直接的排序函数，但是作为一个学习者，我们应当抱着“知其然，还要知其所以然”的态度去学习。1.常见的排序算法有哪些？
十大排序算法总结与实现
jaredray的博客
03-31 1361
十大排序算法
几种常见的排序算法的实现与性能分析数据结构课程设计报告.doc
11-30
这篇文档是关于数据结构课程设计的一份报告，主要探讨了六种常见的排序算法：起泡排序、直接排序（插入排序）、简单选择排序、快速排序、希尔排序和堆排序。报告的目标是实现这些算法并分析它们在不同数据集下的比较...
python 常见的排序算法实现汇总
09-16
本文将深入探讨几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序和归并排序。这些算法主要分为比较类排序，它们通过元素之间的比较来决定顺序。 1. **冒泡排序**：冒泡...
python实现八大常见排序算法
12-21
本篇文章将探讨八大常见排序算法的Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、计数排序和基数排序。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，它通过重复...
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
Mybatis反射实现装载Mapper
xdkb159的博客
12-09 1998
啥地方
jdk 1.8 新特性之——stream Collectors
xdkb159的博客
02-24 1487
Collectors的俩个作用： 1、将数据流缩减为一个单一值，可以是一个collection、基本数据类型或者一个自定义对象； 2、将数据流中的元素进行分组，根据任务类型将流中所有的任务进行分组。这将产生一个Map<TaskType, List<Task>>的结果，其中每个实体包含一个任务类型以及与它相关的任务。你也可以使用除...
xml解析——注解辅助解析
xdkb159的博客
01-09 1200
先上测试xml报文: &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;Request&gt; &lt;Head&gt; &lt;CODE&gt;0000&lt;/CODE&gt; &lt;id&gt;11111&lt;/id&gt; &lt;TIMESTAMP&
java线程之——FutureTask
xdkb159的博客
10-19 574
一、FutureTask的实现 FutureTask实现了RunnableFuture，既即实现Runnable接口和Future接口。所以FutureTask实现run方法，以及Future接口的一系列计算结果方法 二、构造方法 FutureTask有两个构造方法，分别为一个参数和两个参数，如下图： 一个参数构造器传入一个Callable实现，需要返回参数； 第二个构造器第一个参数...
jdk 1.8 新特性之——stream流的学习
xdkb159的博客
02-08 524
1、流的特点 流只能遍历一次，流中的元素向流水线一样经过一个或多个中间操作，最后执行终端操作，完成流的遍历。 流采用内部迭代。 2.流的操作 类型 中间操作—— 返回一个stream，同一个stream可以进行多个中间操作。 filter：过滤操作，filter函数接收一个Lambda表达式作为参数，该表达式返回boolean； map：转换操作，map函数将stream的元素转换成另一种类型输出； ...
Java面试知识点笔记
xdkb159的博客
08-31 516
基础 面向对象的特征 封装：将客观事物封装成抽象的类，并对属性和方法实现访问控制； 继承：继承父类的非私有属性和方法，分为实现继承和接口继承，实现继承不需要实现方法，接口继承继承抽象方法，需要实现方法； 多态：一个实例的相同方法在不同的情形下有不同的表现形式，父类引用不同的子类实现； 抽象：数据抽象->类的属性，过程抽象->类的方法。 final, finally, finalize 的区别 final：常量关键字，标识属性时，属...
计算后缀表达式
xdkb159的博客
06-28 307
出栈入栈实现后缀表达式的计算
java 反射机制
xdkb159的博客
02-25 218
反射，在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。public class Flection { public static void main(String[] args) throws Exception { Class&lt;Book...
排序算法解析：快速排序与其他常见算法对比
"快速排序算法演示及各种排序算法的比较" 快速排序是一种高效的排序算法，由C.A.R. Hoare在1960年提出。它的基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值