冒泡排序，选择排序，插入排序

冒泡排序，选择排序，插入排序

       小规模的文件以及基本有序的文件，插入排序的性能比快速排序的性能更为有效一些，实际上，插入排序通常也做快速排序实现的一部分。

 

1 冒泡排序：

       package datastrut;

 

public class BubbleSort {

 

    /**

     * 冒泡排序

     * @param args

     */

   

    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.print(a[i] + " ");

       System.out.println(" ");

    }

    public void swap(int one,int two){

       long temp = a[one];

       a[one] = a[two];

       a[two] = temp;

      

    }

    public void bubbleSort(){

       int out,in;

       for(out = nElems-1;out>1;out--){

           for(in = 0 ; in < out; in++){

              if(a[in]>a[in+1]){

                  swap(in,in+1);

              }

           }

       }

      

    }

   

   

    public static void main(String[] args) {

       // TODO Auto-generatedmethod stub

       int maxsize = 100;

       BubbleSort b= new BubbleSort(maxsize);

       b.insert(12);

       b.insert(45);

       b.insert(65);

       b.insert(34);

       b.insert(76);

       b.insert(13);

       b.insert(15);

       b.insert(78);

       b.insert(67);

       b.insert(76);

      

       b.display();

       b.bubbleSort();

       b.display();

      

    }

 

}

 

效率：(n-1)+(n-2)+…+1= n*(n-1)/2     大约 O(n^2)

 

       比较次数大约：n^2/2   交换次数：n^2/4

 

 

 

 

2，选择排序：

   冒泡排序的一种改进，交换次数从O（n^2）减少到O（n），但比较次数仍为O(n^2)

 

    /*

     * 选择排序

     * */

    public void selectSort(){

       int min,out,in;

       for(out = 0;out < nElems - 1; out++){

           min = out;

           for(in = out + 1; in < nElems;in++){

              if(a[in] > a[min])

                  swap(in,min);

           }

          

       }

      

      

    }

选择排序的效率：O(n^2)

       交换次数从O（n^2）减少到O（n），但比较次数仍为O(n^2)

       当N值较小时，特别是如果交换的时间级比比较时间级大得多时，选择排序实际上是相当快的。

 

3，插入排序

       仍然需要O(n^2) ,但是一般情况下，它要比冒泡排序快一倍，比选择排序还要快一点。

    /*

     * 插入排序

     * */

    public void insertSort(){

       int in,out;

       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;

       }

    }

 

插入排序性能：对于已经有序或者基本有序的数据来说，插入排序要好得多。当数据有序的时候，while循环的条件总是假，所以他变成了外层循环中的一个简单语句，执行n-1次，O(n)。

如果数据基本有序，插入排序几乎只需要O(n)的时间。

 

 

三种性能比较：

1， 冒泡：数据量小的时候。交换O(n^2)，比较O(n^2)

2， 选择：数据量小，交换数据相对于比较数据更加耗时时。交换O(n)，比较O(n^2)

3， 插入：数据量小或者基本有序时。复制O(n^2)，比较O(n^2) 一次复制与一次交换的时间耗费不同。

都需要一个额外的变量来暂时存储交换时的数据项。

舍拉官方店