时间排序_几种常见排序方法的实现及时间对比（JAVA）

最新推荐文章于 2021-02-25 05:19:35 发布
最新推荐文章于 2021-02-25 05:19:35 发布
阅读量723 收藏
点赞数
文章标签： 时间排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34035088/article/details/112595463
版权

220ac7ce6c81f3b514b4fc12b6ad68a3.png

首先贴出工具类

ArrayUtil:

import org.apache.commons.lang3.time.StopWatch;

public class ArrayUtil {

    //交换数组元素
    public static void swap(Comparable[] array, int left, int right) {
        Comparable tempValue = array[left];
        array[left] = array[right];
        array[right] = tempValue;
    }

    //比较元素
    public static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //打印
    public static void show(Comparable[] array) {
        StringBuilder sb = new StringBuilder();
        for (Comparable a : array) {
            sb.append(a).append(" ");
        }
        System.out.println("排序后：" + sb.toString());
    }

    //判断是否有序
    public static boolean isSort(Comparable[] array) {
        for (int i = 1; i < array.length; i++) {
            if (less(array[i], array[i - 1])) {
                return false;
            }

        }
        return true;
    }

    //选择排序方式，计算时间
    public static double runTime(String method, Comparable[] array) throws Exception {
        StopWatch watch = new StopWatch();
        watch.start();
        switch (method) {
            case "Insertion": {
                InsertSort.sort(array, 0, array.length);
                break;
            }
            case "Selection": {
                SimpleSelectionSort.sort(array);
                break;
            }
            case "Shell": {
                ShellSort.sort(array);
                break;
            }
            case "Quick": {
                QuickSort.optimizeSort(array, 0, array.length - 1);
                break;
            }
            //快速排序的三向切分
            case "Quick3Way":{
                QuickSort.quick3way(array,0,array.length-1);
                break;
            }
            case "Heap": {
                HeapSort.sort(array);
                break;
            }
            case "Bubble": {
                BubbleSort.sort(array);
                break;

            }
            //自顶向下归并
            case "Merge": {
                Comparable[] aux = new Comparable[array.length];
                Merge.mergeSort(array, aux, 0, array.length - 1);
                break;
            }
            //自底向上归并
            case "MergeBU": {
                Merge.mergeSortBu(array);
                break;
            }
            default: {
                throw new Exception("error");
            }
        }

        watch.stop();
        if (isSort(array)) {
            return watch.getNanoTime();
        }
        throw new RuntimeException(method+"排序不成功");
    }

    /**
     * @param method 使用排序方法的名称
     * @param count  生成几组数据
     * @param length 每组数据的长度
     * @return total 平均使用时间 单位ms
     * @throws Exception e
     */
    public static void timeRandomInput(String method, int count, int length) throws Exception {
        double total = 0.0;
        Comparable[] array = new Comparable[length];
        for (int i = 0; i < count; i++) {
            for (int j = 0; j < length; j++) {
                array[j] = StdRandom.uniform() * 100;
            }

            total += runTime(method, array);
        }
        double ms = total/count/100000;
        String formatMs = String.format("%.2f", ms);
        System.out.println(method+" 平均运行时间:"+formatMs);
    }

}

随机数生成类:

import java.util.Random;

/**
 * 此类提供一系列产生随机数的方法，以满足不同用例需要
 *
 * @author crazyMonkey
 */

public final class StdRandom {

//随机数对象

    private static Random random;

//用于产生随机数的种子

    private static long seed;

// 静态初始化区域

    static {

//产生随机数种子

        seed = System.currentTimeMillis();

        random = new Random(seed);

    }

    private StdRandom() {
    }

/***********************************************************
 * 产生基本的随机数
 ***********************************************************/

    /**
     * 获取此类实例的伪随机种子生成器
     */

    public static void setSeed(long s) {

        seed = s;

        random = new Random(seed);

    }

    /**
     * 获取此类实例提供的伪随机种子生成器
     */

    public static long getSeed() {

        return seed;

    }

    /**
     * 返回一个随机的范围在[0,1)之间的double类型的数
     */

    public static double uniform() {

        return random.nextDouble();

    }

    /**
     * 返回一个随机的范围在[0,N)之间的int类型的数
     */

    public static int uniform(int N) {

        return random.nextInt(N);

    }

    /**
     * 返回一个范围在 [0, 1)的实数
     */

    public static double random() {

        return uniform();

    }

    /**
     * 返回一个范围在 [a, b)的int类型值
     */

    public static int uniform(int a, int b) {

        return a + uniform(b - a);

    }

    /**
     * 返回一个范围在 [a, b)的实数
     */

    public static double uniform(double a, double b) {

        return a + uniform() * (b - a);

    }

}

快速排序

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序。

代码:

public class QuickSort {


    public static void optimizeSort(Comparable[] array, int left, int right) {
        optimizeAdjust(array, left, right);
    }

    /**
     * @param array 待排序数组
     * @param left  数组的左界
     * @param right 数组的右界
     */

    //三数取中切分
    private static void optimizeAdjust(Comparable[] array, int left, int right) {
        if (left < right) {
            if (right - left <= 15) {
                InsertSort.sort(array, left, right);
                return;
            }
            int i, j;
            Comparable key;
            i = left;
            j = right;
            int mid = i + (j - i) / 2;
            if (ArrayUtil.less(array[j], array[mid])) {
                ArrayUtil.swap(array, mid, j);
            }
            if (ArrayUtil.less(array[j], array[i])) {
                ArrayUtil.swap(array, i, j);
            }
            if (ArrayUtil.less(array[i], array[mid])) {
                ArrayUtil.swap(array, mid, i);
            }
            key = array[i];

            while (ArrayUtil.less(i, j)) {
                while (ArrayUtil.less(i, j) && !ArrayUtil.less(array[j], key)) {
                    // 从右向左找第一个小于x的数
                    j--;
                }
                array[i] = array[j];
                while (i < j && !ArrayUtil.less(key, array[i])) {
                    // 从左向右找第一个大于x的数
                    i++;
                }
                array[j] = array[i];
            }
            array[i] = key;
            commonAdjust(array, left, i - 1);
            commonAdjust(array, i + 1, right);
        }
    }


    public static void quick3way(Comparable[] a,int left,int right){
        if (right<=left) return;
        int lt =left,  i = left+1,gt = right;
        Comparable key = a[left];
        while (i<=gt){
            int temp = a[i].compareTo(key);
            if (temp<0){
                ArrayUtil.swap(a,lt++,i++);
            }else if (temp>0){
                ArrayUtil.swap(a,gt--,i);
            }else {
                i++;
            }
        }
        quick3way(a,left,lt-1);
        quick3way(a,gt+1,right);
    }
}

冒泡排序:

public class BubbleSort {

    public static void sort(Comparable[] array) {

        int len = array.length;
        int key = len - 1;
        //用来标记，如果未标记，则表示没有发生交换，说明数组有序
        int flag = 0;
        //用来记录发生交换时的位置，这个位置之后，数组有序
        int pos = 0;
        //进行正向遍历后，再进行反向遍历
        int start = 0;
        for (int i = 0; i < len - 1; i++) {
            flag = 0;
            for (int j = start; j < key; j++) {
                if (ArrayUtil.less(array[j+1],array[j])) {
                    ArrayUtil.swap(array, j, j + 1);
                    flag = 1;
                    pos = j;
                }
            }
            if (flag == 0) {
                break;
            }
            flag = 0;
            key = pos;
            //反向遍历，把最小值遍历到数组的左端
            for (int k = key;k>start;k--){
                if (ArrayUtil.less(array[k],array[k-1])){
                    ArrayUtil.swap(array,k,k-1);
                    flag = 1;
                }
            }
            start++;
            if (flag == 0) {
                break;
            }
        }


    }
}

插入排序:

public class InsertSort {
    /*
     * 插入排序 整体思路还是很简单,稍微优化，减少了数组的交换 复杂度N^2
     */
    public static void sort(Comparable[] array,int start,int end) {
        Comparable key;
        for (int i = start+1; i < end; i++) {
            key = array[i];
            int j = i;
            for (;j > start && ArrayUtil.less(key, array[j - 1]); j--) {
                array[j] = array[j-1];
            }
            array[j] = key;
        }
    }
}

希尔排序：

public class ShellSort {
    /*
     * 希尔排序 插入排序的优化算法
     * h相等于步长，计算h的方法3*h+1,（1,4,13,40.....）
     * 数组从0开始，步长为h，将0，0+h,0+2h...算作一个新的数组，对它们进行插入排序
     * 从最大的h开始，每次插入排序后，h/=3,直到h=1，排序完成
     * 运用了和插入排序同样的优化方法，减少了数组的交换
     */
    public static void sort(Comparable[] array){
        int len = array.length;
        int h =1;
        while (h<len/3){
            h=3*h+1;
        }
        Comparable key;
        while (h>=1){
            for (int i = h;i<len;i++){
                int j =i;
                key = array[i];
                for (;j>=h && ArrayUtil.less(key,array[j-h]);j-=h){
                    array[j] = array[j-h];
                }
                array[j] = key;
            }
            h/=3;
        }
    }
}

选择排序:

//简单选择排序，选择数组中最小的数，与数组左端交换，交换过后将左端下标+1
public class SimpleSelectionSort {
    public static void sort(Comparable[] array){
        int min;
        int len = array.length;
        for(int i = 0;i<len-1;i++){
            min = i;
            for (int j=min+1;j<len;j++){
                if (ArrayUtil.less(array[j],array[min])){
                    min = j;
                }
            }
            if (i!=min){
                ArrayUtil.swap(array,i,min);
            }
        }
    }
}

堆排序:

public class HeapSort {

    /*
     *初始化堆,规则：非叶子结点的值必定大于它的叶子结点，堆的顶端为数组的最大值
     *建立堆过程自下而上
     */
    public static void sort(Comparable[] array) {

        initHeap(array);
        int count = array.length;
        while (count > 1) {
            //交换数组的第0位和最后一位，第一位总是为数组最大值，然后将待排序个数减一
            ArrayUtil.swap(array,count-1,0);
            count--;
            buildHeap(array, count, 0);
        }
    }

    private static void initHeap(Comparable[] array) {
        int arrayLen = array.length;
        for (int index = (arrayLen / 2 - 1); index >= 0; index--) {
            buildHeap(array, arrayLen, index);
        }
    }

    /**
     *
     * @param array 待排序数组
     * @param count 待排序元素的个数
     * @param index 元素的索引值
     */
    private static void buildHeap(Comparable[] array, int count, int index) {
        int maxChildIdx;
        while (index <= count / 2 - 1) {
            //判断结点时候为偶数，如果是则只有左叶子结点
            if (count % 2 == 0 && index == count / 2 - 1) {
                maxChildIdx = index * 2 + 1;
            } else {
                int leftChildIdx = index * 2 + 1;
                int rightChildIdx = index * 2 + 2;
                //判断左右叶子结点谁大，并赋值
                maxChildIdx = ArrayUtil.less(array[leftChildIdx],array[rightChildIdx]) ?
                            rightChildIdx: leftChildIdx;
            }
            /*
             *判断结点是否大于它的父节点，是就交换它们，赋值进入下一次判断
             * 建堆是自下而上的过程，while循环是自上而下再判断
             */
            if (ArrayUtil.less(array[index] , array[maxChildIdx])) {
                ArrayUtil.swap(array,index,maxChildIdx);
                index = maxChildIdx;
            } else {
                break;
            }
        }
    }

}

归并排序的两种：

public class Merge {
   
    public static void mergeSort(Comparable[] dest, Comparable[] src, int l, int r) {
        if (l < r) {
            int mid = (l + r) / 2;
            mergeSort(dest, src, l, mid);
            mergeSort(dest, src, mid + 1, r);
            merge(dest, src, l, mid, r);
        }
    }
    public static void mergeSortBu(Comparable[] array){
        int N = array.length;
        Comparable[] aux = new Comparable[N];
        for (int n = 1; n < N; n = n+n) {
            for (int i = 0; i < N-n; i += n+n) {
                int lo = i;
                int m  = i+n-1;
                int hi = Math.min(i+n+n-1, N-1);
                merge(array, aux, lo, m, hi);
            }
        }
    }
    public static void merge(Comparable[] a,Comparable[] aux,int left,int mid,int right){
        int i = left;
        int j = mid+1;
        for (int k = left;k<=right;k++){
            aux[k] = a[k];
        }
        for (int k = left;k<=right;k++){
            if (i>mid){
                a[k] = aux[j++];
            } else if (j>right) {
                a[k] = aux[i++];
            }
            else if (ArrayUtil.less(aux[j],aux[i])){                  a[k] = aux[j++];
            }else {
                a[k] = aux[i++];
            }
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args) throws Exception {
        int count = 3;
        int Length = 10000;
        ArrayUtil.timeRandomInput(SortMethod.INSERTION, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.SELECTION, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.MERGE_BU, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.MERGE, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.BUBBLE, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.COMMON_QUICK, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.QUICK_3WAY, count, Length);
        ArrayUtil.timeRandomInput(SortMethod.HEAP, count, Length);
    }
}

运行截图：

99f8b5c98b4eb2a278aa86052dad04f0.png

6a11c9d44039beda4abd0188a4f786e0.png

043f716044dc8c9a351c5c390314c75d.png
AIRPHOTO定义新视觉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java语言排序——选择排序法和冒泡排序法（排序时间的测试盒比较）
04-12
NULL 博文链接：https://ninghui521.iteye.com/blog/1697377
几种线性时间排序
SeasonJoe的博客
07-26 1893
一般我们使用的堆排序，归并排序都是属于比较排序，也就是通过比较元素的大小来进行排序，可以通过决策树分析出比较排序的时间下界是O(nlgn)，堆排序和归并排序都是渐进最优的比较排序算法。还有其他的排序方法不是通过比较，下面总结一下： 一：计数排序 大致思路是将数组中所有元素对应小于这个元素的个数存储起来，这样我们可以直接知道这个元素的位置，因为可能出现相同的元素，所以我们从后面输出而且每次找到一
java四大排序算法区别_各种排序算法的总结、比较与Java实现
weixin_36440677的博客
02-16 436
1 快速排序(QuickSort)快速排序是一个就地排序，分而治之，大规模递归的算法。从本质上来说，它是归并排序的就地版本。快速排序可以由下面四步组成。(1)如果不多于1个数据，直接返回。(2)一般选择序列最左边的值作为支点数据。(3)将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。(4)对两边利用递归排序数列。快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况...
冒泡排序 java_Java中数组的冒泡排序、选择排序、快速排序
weixin_39947501的博客
12-16 83
一、代码及效果图1.冒泡排序代码如下（示例）：public class Hello1 { public static void main(String[] args) { int arr[]={9,4,5,6,8,1,40}; for (int i = 1; i <=arr.length-1; i++) { for (int j...
Java实现选择排序和冒泡排序执行时间的比较
weixin_30883271的博客
03-03 174
有一天，突然有个idea，想知道选择排序和冒泡排序到底谁快谁慢，于是，写了代码来测试。 1.冒泡排序 View Code /*** * bobble sorting * @param arr */ static void bobble(int arr[]) { boolean flag = false; ...
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
Java实现几种常见排序方法
03-06
### Java 实现几种常见排序方法 #### 泡泡排序（Bubble Sort） 泡泡排序是一种简单的排序算法，它重复地遍历待排序的数列，依次比较相邻的两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复...
Java时间类型和字符串之间的各种转换及几种常见的排序
04-18
个人积累的Java工具类扩展类，包括字符数组转字符串，质数判断，辗转相除法求最大公约数，对字符串的一些判断，几种常见的数组排序、插入、查找等，闰年判断 日期字符串解析等与日期有关的操作，随机字符串。...
Java实现储存对象并按对象某属性排序的几种方法示例
08-19
下面将详细介绍三种在Java中实现这一目标的方法，以及如何使用这些方法来优化排序过程。 **第一种方法：使用`TreeSet`** `TreeSet`是Java集合框架中的一个有序集合，它会自动对其中的元素进行排序。对于基本数据...
java几种排序算法的实现及简单分析
09-03
本文将详细介绍几种常见的排序算法的实现方式及其性能分析，包括插入排序、折半插入排序、希尔排序、选择排序和堆排序。 1. **插入排序（Insertion Sort）**： 插入排序是一种简单直观的排序算法。它的基本思想是...
java数组排序
09-04
java数组排序的思想，过程和代码实现。多种数组排序的方法，主要有冒泡排序，堆排序，插入排序， 归并操作(merge)， 归并操作(merge)，选择排序，希尔排序。
java排序比较_Java几种排序方法比较
weixin_27437725的博客
02-21 263
package com.sort;public class Sort {public void swap(int a[], int i, int j) {int tmp = a[i];a[i] = a[j];a[j] = tmp;}public int partition(int a[], int low, int high) {int pivot, p_pos, i;p_pos = low;pi...
时间的比较排序java_java7大非线性时间比较类排序
weixin_32526561的博客
02-25 146
java7大非线性时间比较排序时间、空间复杂度的比较一、冒泡排序一、基本思想冒泡排序(Bubble Sort)，是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮...
八种排序算法的运行时间比较（附代码）
qq_36070644的博客
02-18 4877
算法的运行时间与cpu的性能相关，且存在误差，运行时长会有波动。 /* */
人工智能常用的29种算法_8种常用排序算法总结(1)
weixin_40001924的博客
12-04 2097
先总结一下算法的时间复杂度此文章只对前4种算法做总结一. 冒泡排序(BubbleSort)基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。过程：比较相邻的两个数据，如果第二个数小，就交换位置。从后向前两两比较，一直到比较最前两个数据。最终最小数被交换到起始的位置，这样第一个最小数的位置就排好了。继续重复上述过程，依次将第2.3...n-1个最小数排好位置。平均时间复杂度：O(n2)java...
各种排序的运行时间对比
yuanjianchuan的专栏
03-23 1495
冒泡排序 [cpp] view plain copy   //time:34.220s   #include   #include   #include   #include   using namespace std;   class MY{       int a;   //public:       friend o
【基础笔记】各种排序算法及时间空间复杂度对比 Java
michiko98的博客
04-19 233
1. 冒泡排序 public static void main(String[] args) { // 主方法 int[] arr = { 1, 100, 35, 29, 0, -31, -88, 97, 4, 7 }; bubbleSort(arr); System.out.println(Arrays.toString(arr)); } /** * 冒泡排序算法： 从...
常见的排序算法即排序时间长短（提升版）
qq_45893999的博客
07-10 1749
文章目录排序算法 排序算法
按时间排序的那个代码咋写?帮下哈!
weixin_34161029的博客
07-08 190
谢谢 转载于:https://www.cnblogs.com/zhouqi/archive/2008/07/08/1238130.html
Java实现常见排序算法详解
本文档详细介绍了几种经典的排序算法在Java语言中的实现，主要关注以下几点： 1. **插入排序**：插入排序分为直接插入排序和希尔排序。直接插入排序是将每个元素插入到已排序部分的正确位置，而希尔排序是改进的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值