选择、插入、冒泡排序实现和比较

看代码(这三个排序可以排序实现Comparable接口的对象)

我自己把选择和冒泡搞混了，所以在这里给那些可能搞混的人说明一下，选择和冒泡是俩个不同的代码，简单的来说选择排序每次遍历只交换一次（或不交换），冒泡排序则可能交换多次，虽然这三者时间复杂度都为O^2,但选择好像是最快的在这三者中，冒泡最慢，主要原应是交换的次数，选择交换最少。

public class Sort_Comparable {

/**
* 判断俩个对象（实现Comparable接口的对象）大小，
* 若第一个对象小则返回true,反之返回false
* @param i
* @param j
* @return
*/
public static boolean less(Comparable i, Comparable j){
return i.compareTo(j)<0;
}

/**
* 交换数据
* @param data
* @param i
* @param j
*/
public static void exch(Comparable[] data, int i, int j){
Comparable tem;
tem=data[i];
data[i]=data[j];
data[j]=tem;
}

/**
* 输出数据
* @param data
*/
public static void showData(Comparable[] data){
int rowNum=0;
for(int i=0; i<data.length; i++){
System.out.print(data[i]+"\t");
rowNum++;
if(rowNum>=10){
rowNum=0;
System.out.println();
}
}
System.out.println();
}

public static boolean isSort(Comparable[] data){
for(int i=1; i<data.length; i++){
if(less(data[i] , data[i-1]))
return false;
}
return true;
}

/**
* 选择排序（由小到大）
* 每次找到最小的对象再交换
* @param data
*/
public static void SelectSortMethod(Comparable[] data){
long start=System.currentTimeMillis();
for(int i=0; i<data.length-1; i++){
int min=i;
for(int j=i+1; j<data.length; j++){
if(less(data[j], data[min])){
min=j;
}
}
exch(data, min, i);
}
long end=System.currentTimeMillis();
System.out.println("选择排序花费时间："+(end-start)+"ms");
}

/**
* 冒泡排序(由小到大)
* 每次将比当前对象小的对象与当前对象交换--
* （与选择排序不同，选择排序每次遍历只交换一次（或不交换），冒泡排序则可能交换多次）
* @param data
*/
public static void BubbleSortMethod(Comparable[] data){
long start=System.currentTimeMillis();
for(int i=0; i<data.length-1; i++){
for(int j=i+1; j<data.length; j++){
if(!less(data[i], data[j])){
exch(data, i, j);
}
}
}
long end=System.currentTimeMillis();
System.out.println("冒泡排序花费时间："+(end-start)+"ms");
}

/**
* 插入排序（由小到大）
* 每次将对象插入到当前已排序的数组中（首先把第一个对象看作有序，依次读取对象插入到有序的序列）
* @param data
*/
public static void InsertSortMethod(Comparable[] data){
long start=System.currentTimeMillis();
for(int i=0; i<data.length; i++){
for(int j=i; j>0&&less(data[j], data[j-1]); j--){
exch(data, j, j-1);
}
}
long end=System.currentTimeMillis();
System.out.println("插入排序花费时间："+(end-start)+"ms");
}
}

测试

package suanfa;

public class test {

public static void main(String[] args) {
// TODO Auto-generated method stub
Integer[] data1=new Integer[1000];
Integer[] data2=new Integer[1000];
Integer[] data3=new Integer[1000];
for(int i=0; i<1000; i++){
data1[i]=(int) Math.round(Math.random()*1000);
data2[i]=data1[i];
data3[i]=data1[i];
}
Sort_Comparable.InsertSortMethod(data3);
Sort_Comparable.BubbleSortMethod(data2);
Sort_Comparable.SelectSortMethod(data1);
Sort_Comparable.showData(data3);
}

}

看下结果

插入排序花费时间：24ms
冒泡排序花费时间：29ms
选择排序花费时间：23ms
1 2 3 5 7 8 10 10 11 11
14 15 16 16 16 18 19 19 22 23
23 24 24 24 27 27 27 27 27 28
28 30 30 31 33 33 34 35 35 37
38 38 40 41 43 46 48 49 50 51
54 55 59 60 60 61 61 62 62 64
64 66 66 67 69 70 71 72 76 77
79 82 82 83 87 87 88 89 94 94
95 95 97 97 99 103 106 107 108 108
109 110 110 111 117 118 118 121 122 122
123 123 123 124 124 125 125 127 128 128
129 129 131 131 133 133 133 135 136 138
139 141 141 143 144 144 146 149 149 151
152 152 154 157 157 158 158 158 158 158
160 162 162 163 163 164 165 166 169 170
173 174 176 177 177 178 178 179 180 181
182 184 185 186 187 188 189 191 193 194
196 197 203 203 204 205 205 207 207 212
214 214 216 217 218 218 219 220 220 221
221 223 223 223 225 227 227 228 228 231
236 237 238 238 242 243 244 244 245 246
246 248 248 250 251 252 252 254 255 256
258 259 259 260 260 260 261 263 263 266
266 266 269 269 270 270 272 272 274 275
276 277 280 285 285 288 289 289 290 291
292 293 295 295 296 298 298 300 301 302
309 310 310 312 314 315 317 319 320 321
321 321 321 324 324 326 327 328 329 330
330 330 332 333 333 336 336 340 343 343
344 345 345 345 345 346 347 348 348 350
350 351 352 353 354 356 356 357 357 357
357 359 363 363 364 364 365 366 366 368
369 371 372 372 372 373 374 375 378 378
378 379 383 384 384 387 388 388 389 389
389 391 392 395 396 397 398 400 400 402
403 405 406 407 408 410 411 412 413 417
418 418 418 422 424 424 424 425 425 425
425 426 427 428 428 429 431 431 433 434
435 436 436 437 439 439 440 440 441 441
442 443 443 446 446 449 450 450 450 451
452 453 453 453 456 457 457 458 459 462
462 465 465 466 467 467 469 469 471 473
473 474 475 475 476 477 477 478 480 480
481 483 487 488 490 497 498 499 500 500
500 501 502 503 506 506 511 511 512 512
516 520 520 520 521 521 522 523 525 526
527 531 532 532 532 533 533 534 534 536
536 536 540 541 541 541 542 543 543 544
545 545 547 547 547 548 548 549 549 551
551 551 551 552 553 553 553 554 555 557
559 559 559 559 561 561 562 564 564 565
565 565 566 566 567 567 569 570 571 571
571 572 572 573 576 576 576 576 579 580
583 585 585 585 588 588 589 589 590 591
592 592 592 592 593 594 595 596 596 596
597 597 598 599 599 600 601 601 604 607
608 608 609 614 615 617 617 619 621 623
623 624 627 628 630 631 632 633 634 635
636 637 637 639 640 641 643 644 645 645
646 648 649 650 650 650 651 652 653 654
655 656 657 658 658 659 659 662 664 665
666 666 666 667 668 668 668 669 669 671
672 672 673 675 675 676 676 678 679 681
681 682 682 682 683 684 684 686 686 686
687 687 687 688 688 688 689 690 690 691
691 692 698 698 698 698 699 700 700 701
701 702 703 704 705 705 705 707 708 708
708 709 709 710 710 710 711 711 714 714
715 716 716 716 718 718 718 718 721 721
721 721 724 724 724 725 725 726 727 727
728 729 730 731 733 733 734 735 736 737
740 740 741 744 745 747 747 748 749 750
750 751 753 754 755 755 756 756 757 757
758 758 760 761 761 762 762 764 765 767
767 767 767 768 768 770 770 771 771 772
773 774 776 778 778 779 780 781 782 782
783 783 784 785 785 787 790 792 793 795
797 798 798 798 799 799 801 802 802 803
805 805 806 807 807 807 808 810 810 810
810 811 811 811 811 812 812 814 815 815
816 818 818 819 820 822 822 823 823 825
826 829 831 832 832 833 833 834 835 836
837 838 838 839 842 842 843 843 847 848
848 849 849 850 851 851 852 852 853 853
855 857 857 858 858 858 858 860 860 862
862 863 865 866 866 867 867 868 868 869
871 872 872 876 876 877 879 879 880 881
881 883 884 885 886 887 887 888 889 893
893 895 896 897 898 899 900 901 902 903
907 908 908 908 909 909 909 911 911 911
912 913 913 915 915 916 919 920 922 922
922 925 925 927 929 929 930 931 932 934
938 939 940 941 941 942 942 942 942 942
943 944 944 945 945 946 949 950 953 954
955 955 956 957 957 959 962 962 962 963
964 964 964 964 964 964 966 967 968 970
970 971 971 971 972 972 972 972 972 973
973 974 975 978 978 979 980 980 981 981
981 982 983 986 987 990 990 990 990 990
992 993 993 994 994 997 998 999 999 1000

选择、插入、冒泡排序实现和比较相关推荐

php冒泡插入选择排序,说说PHP数组的三种排序(冒泡/选择/插入)方法
说说PHP数组的三种排序(冒泡/选择/插入)方法 PHP #数组 #排序 #冒泡 #选择 #插入2012-05-30 10:17 一.冒泡排序法说明:找到最大的数,排列到最后面,然后继续找例: $ ...
C++数据结构和算法2 栈双端/队列冒泡选择插入归并快排二三分查找二叉树二叉搜索树贪婪分治动态规划
C++数据结构和算法2 栈双端/队列冒泡选择插入归并快排二三分查找二叉树二叉搜索树贪婪分治动态规划博文末尾支持二维码赞赏哦 _ github 章3 Stack栈和队列Queue= ...
插入，选择和冒泡排序原理
插入排序 //插入排序的基本思想: //1.外层循环控制每趟,一般是数组元素长度减一次,因为最后一次不需要在进行排序 //2.内层循环控制每趟的次数,每次让当前索引元素与下一个索引位置元素进行比较,将 ...
选择排序-冒泡排序-归并排序-快速排序-插入排序
选择排序基本思想: 设所排序序列个数为N,i取1,2,3-n-1,从N-i+1个记录(Ri,Ri+1-.Rn)中找出排序码最小的记录,与第i个记录交换,执行N-1次后完成序列的排序. //选择排序 ...
算法笔记-排序算法(冒泡选择插入)
首先罗列一下常见的十大排序算法: 一.冒泡排序 1. 定义: 冒泡排序(Bubble Sorting)的基本思想是:通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则 ...
二分算法，选择，冒泡排序算法
package com.zlhj.logic.doc; import java.util.Arrays; /** * 类的作用: * * @ClassName : Tser * @Author : l ...
选择加冒泡排序法与找鞍马之总结与感受
选择排序法本题要求将给定的n个整数从大到小排序后输出. 输入格式: 输入第一行给出一个不超过10的正整数n.第二行给出n个整数,其间以空格分隔. 输出格式: 在一行中输出从大到小有序的数列,相邻数字 ...
选择排序冒泡排序二分查找
选择排序 int [] arr = {2,48,28,32,90,12}; for(int i= 0: i < arr.length - 1;i++){ for(int j = i + 1; j ...
iOS swift 选择排序冒泡排序快速排序
返回上级目录:iOS 算法题三大经典排序 | 冒泡排序,选择排序,快速排序 - 知乎文章目录 1.选择排序 2.冒泡排序 3.快速排序 1.选择排序 //选择排序 func rankSelect( ...
mysql 选择插入语句_带有last_insert_id()的Mysql多行插入 – 选择语句
好.所以缺点是,我试图做一个INSERT SELECT,例如: START TRANSACTION; INSERT INTO dbNEW.entity (commonName,surname) SEL ...

选择、插入、冒泡排序实现和比较

选择、插入、冒泡排序实现和比较相关推荐

最新文章

热门文章