java冒泡排序 java面向对象的冒泡排序，选择排序和插入排序的比较

其他 2019-07-17 14:18:11 阅读次数: 0

java面向对象的冒泡排序，选择排序和插入排序的比较

这三种排序有俩个过程：

　　1.比较俩个数据。                                     

　　2.交换俩个数据或复制其中一项。

这三种排序的时间级别

　　冒泡排序：比较 （N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2

　　　　　　　交换  0——N2/2 = N2/4

　　　　　　　总时间 3/4*N2

　　选择排序：比较 （N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2

　　　　　　　交换  0——3*（N-1）=3*（N-1）/2=3/2*N

　　　　　　　总时间 N2/2+3/2*N

　　插入排序：第一轮最多比较一次，第二轮最多比较俩次，最后一轮比较N-1次，所以最多比较N*(N-1)/2。

　　　　　　　复制的次数和比较的次数大致相等，但是复制消耗的时间比交换要小.

　　　　　　　比较 0——N*(N-1)/2=N*(N-1)/4=N2/4

　　　　　　　复制 0——N*(N-1)/2=N*(N-1)/4=N2/4

　　　　　　　总时间 N2//2

　　总结：插入排序算法比冒泡快一倍，比选择排序略快一点，但这些算法都是O(N2)的时间级别。

　　

这三种排序的思想　　

　　冒泡排序：在首轮，第一项和第二项比较，将大的放在后面，然后比较第二项和第三项，将大的放在后面，以此类推在首轮结束，最大的数据已经在最后一项了。在一轮轮的比较中，后面的已经排好的数据项越来越多，需要排序的数据项越来越少，直到为零。

　　选择排序：在冒泡排序上做了优化，减少了交换次数，在首轮选择最小的数放在第一项，一轮之后第一项是有序的了，第二轮从第二项开始选择最小的数放在第二项，以此类推，直到整个数组完全有序。

　　插入排序：和前俩种排序不同，插入排序在排序过程中是局部有序，随着插入项的增多，有序部分的项的位置会发生改变，而冒泡排序和选择排序每轮确定的项数的位置是永远不变的。在首轮，选择第二项作为插入项，然后取出这一项放在一个变量中，和前一项比较而且小，则前一项后移到第二项的位置，然后第二项也就是插入项放在前一项的位置，第二轮选择第三项作为插入项然后取出和前一项也就是第二项比较如果小，第二项后移到插入项，然后插入相在和第一项比较如果小，则第一项后移到第二项，插入项放在第一项，以此类推。

这三种排序的java程序

　　1.冒泡排序

复制代码 
package aa;
class BubbleSort{
    private long[] a;
    private int nElems;
    
    public BubbleSort(int max){
        a = new long[max];
        nElems = 0;
    }
    
    public void insert(long value){
        a[nElems] = value;
        nElems ++;
    }
    
    public void display(){
        for(int i = 0; i < nElems; i++)
        {
            System.out.println(a[i] + " ");
        }
        System.out.println("");
    }
    
    public void bubbleSort(){
        for(int i = 0; i < nElems - 1; i++)
        {
            for(int j = 0; j < nElems - 1 - i; j++)
            {
                if(a[j] > a[j + 1])
                {
                    long temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}
public class BubbleSortApp {
    public static void main(String[] args){
        BubbleSort arr = new BubbleSort(100);
        arr.insert(77);
        arr.insert(99);
        arr.insert(44);
        arr.insert(55);
        arr.insert(22);
        arr.insert(88);
        arr.insert(11);
        arr.insert(00);
        arr.insert(66);
        arr.insert(33);
        arr.display();
        arr.bubbleSort();
        arr.display();
    }    
}
复制代码

 　　2.选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package  aa;
 
class  SelectSort{
     private  long [] a;
     private  int  nElems;
     
     public  SelectSort( int  max){
         a =  new  long [max];
         nElems =  0 ;
     }
     
     public  void  insert( long  value){
         a[nElems] = value;
         nElems ++;
     }
     
     public  void  display(){
         for ( int  i =  0 ; i < nElems; i++)
         {
             System.out.println(a[i] +  " " );
         }
         System.out.println( "" );
     }
     
     public  void  SelectionSort(){
         for ( int  i =  0 ; i < nElems -  1 ; i++)
         {
             int  min = i;
             for ( int  j = i +  1 ; j < nElems; j++)
             {
                 if (a[j] < a[min])
                 {
                     long  temp = a[j];
                     a[j] = a[min];
                     a[min] = temp;
                 }
             }
         }
     }
}
 
public  class  SelectSortApp {
     public  static  void  main(String[] args){
         SelectSort arr =  new  SelectSort( 100 );
         arr.insert( 77 );
         arr.insert( 99 );
         arr.insert( 44 );
         arr.insert( 55 );
         arr.insert( 22 );
         arr.insert( 88 );
         arr.insert( 11 );
         arr.insert( 00 );
         arr.insert( 66 );
         arr.insert( 33 );
         arr.display();
         arr.SelectionSort();
         arr.display();
     }  
}

　　3.插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package  aa;
class  InsertSort{
     private  long [] a;
     private  int  nElems;
     
     public  InsertSort( int  max){
         a =  new  long [max];
         nElems =  0 ;
     }
     
     public  void  insert( long  value){
         a[nElems] = value;
         nElems ++;
     }
     
     public  void  display(){
         for ( int  j =  0 ; j < nElems; j++)
         {
             System.out.println(a[j] +  " " );
         }
         System.out.println( "" );
     }
     
     public  void  insertionSort(){
         int  out,in;
         for (out =  1 ; out < nElems; out++)
         {
             long  temp = a[out];
             in = out;
             while (in >  0  && a[in- 1 ] >= temp)
             {
                 a[in] = a[in -  1 ];
                 in --;
             }
             a[in] = temp;
         }
     }
}
public  class  InsertSortApp {
     public  static  void  main(String[] args){
         int  maxSize =  100 ;
         InsertSort arr =  new  InsertSort(maxSize);      
         arr.insert( 77 );
         arr.insert( 99 );
         arr.insert( 44 );
         arr.insert( 55 );
         arr.insert( 22 );    
         arr.insert( 88 );
         arr.insert( 11 );
         arr.insert( 00 );
         arr.insert( 77 );
         arr.insert( 77 ); <br>
         arr.display();
         arr.insertionSort();
         arr.display();
     }
     
}

这三种排序有俩个过程：

　　1.比较俩个数据。                                     

　　2.交换俩个数据或复制其中一项。

这三种排序的时间级别

　　冒泡排序：比较 （N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2

　　　　　　　交换  0——N2/2 = N2/4

　　　　　　　总时间 3/4*N2

　　选择排序：比较 （N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2

　　　　　　　交换  0——3*（N-1）=3*（N-1）/2=3/2*N

　　　　　　　总时间 N2/2+3/2*N

　　插入排序：第一轮最多比较一次，第二轮最多比较俩次，最后一轮比较N-1次，所以最多比较N*(N-1)/2。

　　　　　　　复制的次数和比较的次数大致相等，但是复制消耗的时间比交换要小.

　　　　　　　比较 0——N*(N-1)/2=N*(N-1)/4=N2/4

　　　　　　　复制 0——N*(N-1)/2=N*(N-1)/4=N2/4

　　　　　　　总时间 N2//2

　　总结：插入排序算法比冒泡快一倍，比选择排序略快一点，但这些算法都是O(N2)的时间级别。

　　

这三种排序的思想　　

　　冒泡排序：在首轮，第一项和第二项比较，将大的放在后面，然后比较第二项和第三项，将大的放在后面，以此类推在首轮结束，最大的数据已经在最后一项了。在一轮轮的比较中，后面的已经排好的数据项越来越多，需要排序的数据项越来越少，直到为零。

　　选择排序：在冒泡排序上做了优化，减少了交换次数，在首轮选择最小的数放在第一项，一轮之后第一项是有序的了，第二轮从第二项开始选择最小的数放在第二项，以此类推，直到整个数组完全有序。

　　插入排序：和前俩种排序不同，插入排序在排序过程中是局部有序，随着插入项的增多，有序部分的项的位置会发生改变，而冒泡排序和选择排序每轮确定的项数的位置是永远不变的。在首轮，选择第二项作为插入项，然后取出这一项放在一个变量中，和前一项比较而且小，则前一项后移到第二项的位置，然后第二项也就是插入项放在前一项的位置，第二轮选择第三项作为插入项然后取出和前一项也就是第二项比较如果小，第二项后移到插入项，然后插入相在和第一项比较如果小，则第一项后移到第二项，插入项放在第一项，以此类推。

这三种排序的java程序

　　1.冒泡排序

复制代码 
package aa;
class BubbleSort{
    private long[] a;
    private int nElems;
    
    public BubbleSort(int max){
        a = new long[max];
        nElems = 0;
    }
    
    public void insert(long value){
        a[nElems] = value;
        nElems ++;
    }
    
    public void display(){
        for(int i = 0; i < nElems; i++)
        {
            System.out.println(a[i] + " ");
        }
        System.out.println("");
    }
    
    public void bubbleSort(){
        for(int i = 0; i < nElems - 1; i++)
        {
            for(int j = 0; j < nElems - 1 - i; j++)
            {
                if(a[j] > a[j + 1])
                {
                    long temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}
public class BubbleSortApp {
    public static void main(String[] args){
        BubbleSort arr = new BubbleSort(100);
        arr.insert(77);
        arr.insert(99);
        arr.insert(44);
        arr.insert(55);
        arr.insert(22);
        arr.insert(88);
        arr.insert(11);
        arr.insert(00);
        arr.insert(66);
        arr.insert(33);
        arr.display();
        arr.bubbleSort();
        arr.display();
    }    
}
复制代码

 　　2.选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package  aa;
 
class  SelectSort{
     private  long [] a;
     private  int  nElems;
     
     public  SelectSort( int  max){
         a =  new  long [max];
         nElems =  0 ;
     }
     
     public  void  insert( long  value){
         a[nElems] = value;
         nElems ++;
     }
     
     public  void  display(){
         for ( int  i =  0 ; i < nElems; i++)
         {
             System.out.println(a[i] +  " " );
         }
         System.out.println( "" );
     }
     
     public  void  SelectionSort(){
         for ( int  i =  0 ; i < nElems -  1 ; i++)
         {
             int  min = i;
             for ( int  j = i +  1 ; j < nElems; j++)
             {
                 if (a[j] < a[min])
                 {
                     long  temp = a[j];
                     a[j] = a[min];
                     a[min] = temp;
                 }
             }
         }
     }
}
 
public  class  SelectSortApp {
     public  static  void  main(String[] args){
         SelectSort arr =  new  SelectSort( 100 );
         arr.insert( 77 );
         arr.insert( 99 );
         arr.insert( 44 );
         arr.insert( 55 );
         arr.insert( 22 );
         arr.insert( 88 );
         arr.insert( 11 );
         arr.insert( 00 );
         arr.insert( 66 );
         arr.insert( 33 );
         arr.display();
         arr.SelectionSort();
         arr.display();
     }  
}

　　3.插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package  aa;
class  InsertSort{
     private  long [] a;
     private  int  nElems;
     
     public  InsertSort( int  max){
         a =  new  long [max];
         nElems =  0 ;
     }
     
     public  void  insert( long  value){
         a[nElems] = value;
         nElems ++;
     }
     
     public  void  display(){
         for ( int  j =  0 ; j < nElems; j++)
         {
             System.out.println(a[j] +  " " );
         }
         System.out.println( "" );
     }
     
     public  void  insertionSort(){
         int  out,in;
         for (out =  1 ; out < nElems; out++)
         {
             long  temp = a[out];
             in = out;
             while (in >  0  && a[in- 1 ] >= temp)
             {
                 a[in] = a[in -  1 ];
                 in --;
             }
             a[in] = temp;
         }
     }
}
public  class  InsertSortApp {
     public  static  void  main(String[] args){
         int  maxSize =  100 ;
         InsertSort arr =  new  InsertSort(maxSize);      
         arr.insert( 77 );
         arr.insert( 99 );
         arr.insert( 44 );
         arr.insert( 55 );
         arr.insert( 22 );    
         arr.insert( 88 );
         arr.insert( 11 );
         arr.insert( 00 );
         arr.insert( 77 );
         arr.insert( 77 ); <br>
         arr.display();
         arr.insertionSort();
         arr.display();
     }
     
}

猜你喜欢

转载自www.cnblogs.com/pressur/p/11200607.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022