排序算法java版,速度排行:冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序...
先推荐一篇关于排序算法的文章:http://www.cppblog.com/guogangj/archive/2009/11/13/100876.html
本文思路部分来源于上篇文章,但测得的结果似乎不大相同,不知是因为java的缘故还是因为我算法的缘故,欢迎拍砖。
复习排序,顺便比下各种算法的速度,榜单如下:
1、冒泡排序
2、简单选择排序
3、直接插入排序
4、折半插入排序
5、希尔排序
6、堆排序
7、归并排序
8、快速排序
当然这是慢速排行,哈哈~~
直接上图:单位毫秒
数量 |
冒泡排序 |
简单选择排序 |
直接插入排序 |
折半插入排序 |
希尔排序 |
堆排序 |
归并排序 |
快速排序 |
10000个 |
1578 |
1250 |
672 |
250 |
0 |
15 |
16 |
0 |
15000个 |
3453 |
2765 |
1563 |
531 |
16 |
15 |
16 |
0 |
20000个 |
6140 |
4547 |
2453 |
828 |
16 |
16 |
15 |
16 |
25000个 |
10079 |
7171 |
3969 |
1313 |
31 |
16 |
15 |
16 |
30000个 |
14641 |
10313 |
5578 |
1906 |
31 |
31 |
16 |
31 |
35000个 |
20141 |
14328 |
7890 |
2563 |
31 |
31 |
32 |
15 |
40000个 |
25766 |
18359 |
10094 |
3422 |
47 |
31 |
31 |
32 |
45000个 |
32469 |
24063 |
13062 |
4359 |
47 |
47 |
31 |
47 |
由于"希尔排序","堆排序","归并排序","快速排序"太快,以至于在上图几乎是条直线,故有了下面转为他们准备的加强版
数量 |
希尔排序 |
堆排序 |
归并排序 |
快速排序 |
100000个 |
172 |
140 |
110 |
93 |
200000个 |
469 |
406 |
235 |
234 |
300000个 |
812 |
703 |
422 |
375 |
400000个 |
1125 |
1031 |
516 |
531 |
500000个 |
1406 |
1282 |
719 |
656 |
600000个 |
1828 |
1703 |
860 |
859 |
700000个 |
2531 |
2063 |
1000 |
968 |
800000个 |
2735 |
2453 |
1140 |
1188 |
900000个 |
3047 |
2843 |
1391 |
1266 |
1000000个 |
3375 |
3187 |
1516 |
1422 |
1100000个 |
3922 |
3500 |
1625 |
1609 |
1200000个 |
4421 |
3954 |
1969 |
1812 |
1300000个 |
4797 |
4422 |
2000 |
1953 |
1400000个 |
5391 |
4797 |
2547 |
2094 |
1500000个 |
5437 |
5219 |
2625 |
2328 |
1600000个 |
6203 |
5546 |
2469 |
2485 |
1700000个 |
6532 |
5953 |
2844 |
2672 |
1800000个 |
7125 |
6421 |
2984 |
2844 |
补上代码:
- import java.util.ArrayList;
- import java.util.Arrays;
- import java.util.List;
- /**
- * 插入排序:直接插入排序、折半插入排序和系尔排序
- * 交换排序:冒泡排序和快速排序
- * 选择排序:简单选择排序和堆排序
- * 归并排序:归并排序
- *
- * 基本思想
- * 插入排序:将第N个记录插入到前面(N-1)个有序的记录当中。
- * 交换排序:按照某种顺序比较两个记录的关键字大小,然后根据需要交换两个记录的位置。
- * 选择排序:根据某种方法选择一个关键字最大的记录或者关键字最小的记录,放到适当的位置。
- *
- * 排序方法比较
- * 排序方法 平均时间 最坏时间 辅助存储
- * 直接插入排序 O(N2) O(N2) O(1)
- * 起泡排序 O(N2) O(N2) O(1)
- * 快速排序 O(Nlog2N) O(N2) O(Nlog2N)
- * 简单选择排序 O(N2) O(N2) O(1)
- * 堆排序 O(Nlog2N) O(Nlog2N) O(1)
- * 归并排序 O(Nlog2N) O(Nlog2N) O(n)
- * 基数排序 O(d(n+radix)) O(d(n+radix)) O(radix)
- *
- *
- *
- * @author Administrator
- *
- */
- public class SortTest {
- public static void main(String[] args)throws Exception {
- //测试排序是否正确
- //String[] testErr=new String[]{"冒泡排序","简单选择排序","直接插入排序","折半插入排序","系尔排序","堆排序","归并排序","快速排序"};
- //new SortTest().testErr(testErr);
- //排序1(全部)
- String[] strs=new String[]{"冒泡排序","简单选择排序","直接插入排序","折半插入排序","希尔排序","堆排序","归并排序","快速排序"};
- new SortTest().test(strs,10000,50000,5000);
- //排序2(加强)
- String[] strs2=new String[]{"希尔排序","堆排序","归并排序","快速排序"};
- new SortTest().test(strs2,100000,1900000,100000);
- }
- private void testErr(String[] strings) throws Exception{
- //System.out.println(Arrays.toString(old));
- System.out.println(Arrays.toString(strings));
- Number[] old=getRundom(50);
- Integer[] oo={1,2,3,3,2,21,5,6,7,78,5,65,8,7,6,6,6,6,6,9,56544,354,32,4,456,8,89,-9,0,3,243,-321,321,-3,-2,21};
- old=oo;
- for(String s:strings){
- Number[] testNum=Arrays.copyOf(old, old.length);
- long begin=System.currentTimeMillis();
- SortTest.class.getMethod(s, Number[].class).invoke(this, (Object)testNum);
- long end=System.currentTimeMillis();
- System.out.println(s+":"+(end-begin)+"\t");
- System.out.println(Arrays.toString(testNum));
- }
- System.out.println();
- }
- private void test(String[] strings,long begin,long end,long step) throws Exception{
- System.out.print("数量\t");
- for(String str:strings){
- System.out.print(str+"\t");
- }
- System.out.println();
- for(long i=begin;i<end;i=i+step){
- System.out.print(i+"个\t");
- Number[] old=getRundom(i);
- for(String s:strings){
- Number[] testNum=Arrays.copyOf(old, old.length);
- long beginTime=System.currentTimeMillis();
- SortTest.class.getMethod(s, Number[].class).invoke(this, (Object)testNum);
- long endTime=System.currentTimeMillis();
- System.out.print((endTime-beginTime)+"\t");
- //System.out.println(Arrays.toString(testNum));
- }
- System.out.println();
- }
- }
- private static Integer[] getRundom(long num) {
- List<Integer> list=new ArrayList<Integer>();
- for(long i=0;i<num;i++){
- int k;
- if(Math.random()>0.5){
- k=(int)(Math.random()*Integer.MAX_VALUE);
- }else{
- k=(int)(Math.random()*Integer.MIN_VALUE);
- }
- list.add(k);
- }
- return list.toArray(new Integer[list.size()]);
- }
- /**
- * 插入排序————直接插入排序
- * @param data
- */
- public static void 直接插入排序(Number[] data)
- {
- Number tmp=null ;
- for(int i=1;i<data.length;i++){
- tmp = data[i];
- int j=i-1;
- while(j>=0 && tmp.doubleValue()<data[j].doubleValue()){
- data[j+1]=data[j];
- j--;
- }
- data[j+1]=tmp;
- }
- }
- /**
- * 插入排序————折半插入排序
- * @param data
- */
- public static void 折半插入排序(Number[] data)
- {
- Number tmp=null ;
- for(int i=1;i<data.length;i++){
- tmp = data[i];
- int smallpoint=0;
- int bigpoint=i-1;
- while(bigpoint>=smallpoint){
- int mid=(smallpoint+bigpoint)/2;
- if(tmp.doubleValue()>data[mid].doubleValue()){
- smallpoint=mid+1;
- }else{
- bigpoint=mid-1;
- }
- }
- for(int j=i;j>smallpoint;j--){
- data[j]=data[j-1];
- }
- data[bigpoint+1]=tmp;
- }
- }
- /**
- * 插入排序————希尔排序
- * @param data
- */
- public static void 希尔排序(Number[] data)
- {
- int span=data.length/7;
- if(span==0)span=1;
- while(span>=1){
- for(int i=0;i<span;i++){
- for(int j=i;j<data.length;j=j+span){
- //组内直接插入排序
- int p = j-span;
- Number temp = data[j];
- while( p >=0 && data[p].doubleValue() > temp.doubleValue()){
- data[p+span] = data[p];
- p -=span;
- }
- data[p + span] = temp;
- }
- }
- span=span/2;
- }
- }
- /**
- * 交换排序————冒泡排序
- *
- * @param data
- */
- public static void 冒泡排序(Number[] data)
- {
- for (int i = 0; i < data.length; i++) {
- //将相邻两个数进行比较,较大的数往后冒泡
- for (int j = 0; j < data.length - i-1; j++) {
- if (data[j].doubleValue()> data[j + 1].doubleValue()) {
- //交换相邻两个数
- swap(data, j, j + 1);
- }
- }
- }
- }
- /**
- * 交换排序————快速排序
- * @param data
- */
- public static void 快速排序(Number[] data)
- {
- QuickSort(data,0,data.length-1);
- }
- private static void QuickSort(Number[] data, int begin, int end) {
- // System.out.println(begin+":"+end);
- if(begin<end){
- //取中点
- int mid=(begin+end)/2;
- if(data[end].doubleValue()<data[begin].doubleValue()){
- swap(data, end, begin);
- }
- if(data[end].doubleValue()<data[mid].doubleValue()){
- swap(data, end, mid);
- }
- if(data[mid].doubleValue()<data[begin].doubleValue()){
- swap(data, mid, begin);
- }
- swap(data, mid, begin);
- // System.out.println(Arrays.toString(Arrays.copyOfRange(data, begin, end)) );
- int min=begin+1;
- int big=end;
- while(true){
- while(min<big && data[min].doubleValue()<data[begin].doubleValue()){min++;}
- while(min<big && data[big].doubleValue()>=data[begin].doubleValue()){big--;}
- if(min>=big){
- break;
- }
- swap(data, min, big);
- }
- if(data[begin].doubleValue()>data[min].doubleValue()){
- swap(data, begin, min);
- }
- if(min>1)
- QuickSort(data,begin,min-1);
- //if(min<end)
- QuickSort(data,min,end);
- }
- }
- /**
- * 选择排序————简单选择排序
- * @param data
- */
- public static void 简单选择排序(Number[] data)
- {
- for (int i = 0; i < data.length-1; i++) {
- int smallPoint=i;
- for (int j = i+1; j < data.length; j++) {
- if (data[smallPoint].doubleValue()> data[j].doubleValue()) {
- smallPoint=j;
- }
- }
- swap(data, i, smallPoint);
- }
- }
- /**
- * 选择排序————堆排序
- * @param data
- */
- public static void 堆排序(Number[] data)
- {
- int n = data.length;
- for(int i=n/2;i>=0;i--){
- keepHeap(data, n, i);
- }
- while (n > 0) {
- swap(data, 0, n-1);
- keepHeap(data, --n, 0);
- }
- }
- private static void keepHeap(Number[] a, int n, int i) {
- Number x = a[i];
- int j = 2 * i + 1;
- while (j <= n - 1) {
- if (j < n - 1 && a[j].doubleValue() < a[j + 1].doubleValue())
- ++j;
- if (a[j].doubleValue() > x.doubleValue()) {
- a[i] = a[j];
- i = j;
- j = 2 * i ;
- } else{
- break;
- }
- }
- a[i] = x;
- }
- /**
- * 归并排序法————归并排序
- * @param data
- */
- public static void 归并排序(Number[] data)
- {
- Number[] result = merge_sort(data,0,data.length-1);
- for(int i=0;i<result.length;i++){
- data[i]=result[i];
- }
- }
- private static Number[] merge_sort(Number[] array, int start, int end){
- Number[] result = new Number[end-start+1];
- if(start< end){
- int mid= (start+end)/2;
- Number[] left= merge_sort(array, start, mid);
- Number[] right = merge_sort(array, mid+1, end);
- result= merge(left,right);
- } else if (start == end) {
- result[0] = array[start];
- return result;
- }
- return result;
- }
- private static Number[] merge(Number[] left, Number[] right) {
- Number[] result = new Number[left.length+right.length];
- int i=0;
- int j=0;
- int k=0;
- while(i< left.length&&j< right.length){
- if(left[i].doubleValue()< right[j].doubleValue()){
- result[k++] = left[i++];
- }else{
- result[k++] = right[j++];
- }
- }
- while(i< left.length){
- result[k++] = left[i++];
- }
- while (j< right.length) {
- result[k++]= right[j++];
- }
- return result;
- }
- /**
- * 交换数组中指定的两元素的位置
- * @param data
- * @param x
- * @param y
- */
- private static void swap(Number[] data, int x, int y) {
- Number temp = data[x];
- data[x] = data[y];
- data[y] = temp;
- }
- }
转载于:https://www.cnblogs.com/ericsun/archive/2013/05/31/3110148.html
排序算法java版,速度排行:冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序...相关推荐
- java 快速排序算法简单_排序算法java版,速度排行:冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序......
先推荐一篇关于排序算法的文章:http://www.cppblog.com/guogangj/archive/2009/11/13/100876.html 本文思路部分来源于上篇文章,但测得的结果似乎 ...
- 温故10个经典排序算法(Java版)
所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法.排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面.一个 ...
- java 排序经典算法,经典排序算法(java版)
交换排序(冒泡排序.快速排序),选择排序(直接选择排序.堆排序),插入排序(直接插入排序.希尔排序) 1.冒泡排序算法的运作如下:(从后往前) 比较相邻的元素.如果第一个比第二个大,就交换他们两个. ...
- 【Java数据结构与算法】第七章 冒泡排序、选择排序、插入排序和希尔排序
第七章 冒泡排序.选择排序.插入排序和希尔排序 文章目录 第七章 冒泡排序.选择排序.插入排序和希尔排序 一.冒泡排序 1.基本介绍 2.代码实现 二.选择排序 1.基本介绍 2.代码实现 三.插入排 ...
- java实现八种排序算法并测试速度(详细)
算法代码: /*** Created by CLY on 2017/3/17.*/ package pers.cly.sorting; /*** 排序工具类,里面包含各种排序方法*/ public c ...
- 排序算法---计数排序(java版)
计数排序 原理 计数排序(Counting Sort) 使用了一个额外的数组 C,其中第 i 个元素是待排序数组A 中值等于 i 的元素的个数.然后根据数组 C 来将 A 中的元素排到正确的位置.其实 ...
- java 排序 1和1_新手入门-冒泡排序和选择排序第一节排序1.1排序概述排序(
该楼层疑似违规已被系统折叠 隐藏此楼查看此楼 新手入门-冒泡排序和选择排序 第一节排序 1.1排序概述 排序(sorting)的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列.  ...
- 九大排序算法Java实现
之前学习数据结构与算法时花了三天时间整理九大排序算法,并采用Java语言来实现,今天第一次写博客,刚好可以把这些东西从总结的文档中拿出来与大家分享一下,同时作为自己以后的备忘录. 1.排序算法时间复杂 ...
- Java算法:华为机试算法(下),华为算法Java版,牛客网华为算法73~108题
接上篇:Java算法:华为机试算法(中),华为算法Java版,牛客网华为算法55~72题 HJ73 计算日期到天数转换 计算日期到天数转换 题目描述 根据输入的日期,计算是这一年的第几天.. 测试 ...
最新文章
- Cocos creator加载场景、加载场景回调、预加载场景
- ピエタ~幸せの青い鳥~相关
- 哈钦森之问:动物的种类为何如此丰富?
- Hibernate 笔记1
- C++类与static关键字
- 原生js cookie本地存储
- Ionic系列——调用摄像头拍照和选择图库照片功能的实现
- java如何获得相反的颜色_javascript – 如何根据当前颜色生成相反的颜色?
- javascript 模块化机制
- 解决Qt中文乱码以及汉字编码的问题(UTF-8/GBK)——ubuntu环境设置默认是utf-8,文件编码可使用Encodersoft批量转换
- 一个简单51c语言程序,求一个 89C51 简易计算器的c语言程序 只要加减乘除就行!...
- java中构造器的调用顺序
- python实现pdf到excel的自动批量转换(附 完整代码)
- TCP/IP重传超时--RTO - SRTT (Smoothed Round Trip Time)
- 正样本/反(负)样本/易区分样本/难区分样本
- 消失点:Fast and Accurate Vanishing Point Detection in Complex Scenes
- 【android睡眠唤醒 二】MTK平台唤醒框架分解
- 介绍一些比较方便好用的爬虫工具和服务
- python中数据类型判断方法(学习笔记)
- 云上铺体育场馆管理系统能做什么?
热门文章
- 使用IDEA新建springboot工程
- 使用modernizr.js检测浏览器对html5以及css3的支持情况
- SQL Server 储存过程的output 参数
- [转] Zend studio中开发常用
- 【海洋女神原创】installshield 32位打包和64位打包的注意事项
- jepg图像的存储 转
- VC 文件操作(文件查找,打开/保存,读/写,复制/删除/重命名)
- MySQL数据类型--------字符串类型实战
- Ali RocketMQ与Kafka对照
- 固态硬盘驱动器在设计上有个安全漏洞 易导致数据损毁