比較快速排序，冒泡排序，雙向冒泡排序的執行效率

快速排序

原理是找出一個元素（理論上可以隨便找一個）作為基准(pivot),然后對數組進行分區操作,使基准左邊元素的值都不大於基准值,基准右邊的元素值 都不小於基准值，如此作為基准的元素調整到排序后的正確位置。遞歸快速排序，將其他n-1個元素也調整到排序后的正確位置。最后每個元素都是在排序后的正 確位置，排序完成。所以快速排序算法的核心算法是分區操作，即如何調整基准的位置以及調整返回基准的最終位置以便分治遞歸。

冒泡排序算法

原理是臨近的數字兩兩進行比較,按照從小到大或者從大到小的順序進行交換,

這樣一趟過去后,最大或最小的數字被交換到了最后一位,

然后再從頭開始進行兩兩比較交換,直到倒數第二位時結束

雙向冒泡排序算法

以整數升序排序為例來簡單說明一下雙向冒泡排序的過程：首先從前往后把最大數移到最后，然后反過來從后往前把最小的一個數移動到數組最前面，這一過程就是第一輪，然后重復這一過程，最終就會把整個數組從小到大排列好。雙向冒泡排序要稍微優於傳統的冒泡排序，因為雙向排序時數組的兩頭都排序好了，我們只需要處理數組的中間部分即可，而單向即傳統的冒泡排序只有尾部的元素是排好序的，這時每輪處理都需要從頭一直處理到已經排好序元素的前面一個元素。雖然它在效率上有了點改進，但它也不能大幅度提高其排序的效率，這是由冒泡排序的基本過程所決定了的。在此基礎上改進了一下，下面的代碼可以實現對奇數偶數分別排序

源代碼：

package com.zc.manythread;

public class Sort implements Runnable{
    int[]  date;
    public Sort (int[] date) {
        super();
        this.date=date;
    }
    public void  sort() {
        throw new RuntimeException("please do it in subclass");
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        long start=System.nanoTime();
        sort();
        long end=System.nanoTime();
        System.out.println(Thread.currentThread().getName()+"執行時間："+(end-start)+"ns");
    }

}

package com.zc.manythread;
/**
 * 快速排序
 * @author Administrator
 *
 */
public class QSort extends Sort{

    public void sort() {
        try {
            
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    public QSort(int[] date) {
        super(date);
        // TODO Auto-generated constructor stub
    }
    private void swap(int a[],int i,int j) {
        int T;
        T=a[i];
        a[i]=a[j];
        a[j]=T;
    }
    /*******************
     * 
     * @param a
     * @param lo0
     * @param hi0
     * @return
     */
    int[] QuickSort(int a[],int lo0,int hi0){
        int lo=lo0;
        int hi=hi0;
        int mid;
        if (hi0>lo0) {
            mid=a[(hi0+lo0)/2];
            while(lo<=hi){
                while((lo<hi0)&&(a[lo]<mid))  ++lo;
                
                while((hi>lo0)&&(a[hi]>mid))  --hi;
                
                if (lo<=hi) {
                    swap(a,lo,hi);
                    ++lo;
                    --hi;
                }
                
            }
            if (lo0<hi) {
                QuickSort(a, lo0, hi);
            }
            if (lo<hi0) {
                QuickSort(a, lo, hi0);
            }
        }
        return a;
    }
    /**************
     * 
     * 創建數組數據
     * *****************/
    private static int[]  createDate(int count) {
        int[] data=new int[count];
        for (int i = 0; i < data.length; i++) {
            data[i]=(int)(Math.random()*count);
        }
        return data;
    }
    /**************主函數*****************/
    public static void main(String[] args) {
        final int count=100;
        int[] data=createDate(count);
        for (int n:data) {
            System.out.print(n+"\t");
        }
        QSort data1=new QSort(data);
        System.out.println();
        int[] a=data1.QuickSort(data,0, count-1);
        for (int n:a) {
            System.out.print(n+"\t");
        }
    }
}

package com.zc.manythread;
/**
 * 冒泡排序
 * @author Administrator
 *
 */

public class BSrot extends Sort{

    public void sort() {
        try {
            sort(date);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    public int[] sort(int[] a)throws Exception{
        for (int i = a.length; --i>=0;) {
            boolean swapped=false;
            for (int j = 0; j < i; j++) {
                if (a[j]>a[j+1]) {
                    int T=a[j];
                    a[j]=a[j+1];
                    a[j+1]=T;
                    swapped=true;
                }
            }
            if (!swapped) {
                return a;
            }
        }
        return a;
    }
    public BSrot(int[] date) {
        super(date);
        // TODO Auto-generated constructor stub
    }

}

package com.zc.manythread;
/**
 * 雙向冒泡排序
 * @author Administrator
 *
 */
public class BBSort  extends Sort{

    public BBSort(int[] date) {
        super(date);
        // TODO Auto-generated constructor stub
    }
    
    public void sort() {
        try {
            sort(date);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        
    }
    
    void sort(int[] a)throws Exception{
        int j;
        int limit=a.length;
        int st=-1;
        while(st<limit){
            st++;
            limit--;
            boolean swapped=false;
            for (j = st    ; j < limit; j++) {
                 if (a[j]>a[j+1]) {
                    int T=a[j];
                    a[j]=a[j+1];
                    a[j+1]=T;
                    swapped=true;
                }
            }
            
            if (!swapped) {
                return;
            }else {
                swapped=false;
                for (j = limit; --j>=st;) {
                    if(a[j]>a[j+1]){
                        int T=a[j];
                        a[j]=a[j+1];
                        a[j+1]=T;
                        swapped=true;
                    }
                }
                if (!swapped) {
                    return;
                }
            }
        }
    }

}

package com.zc.manythread;

public class MainTest {
    
    private static int[]  createDate(int count) {
        int[] data=new int[count];
        for (int i = 0; i < data.length; i++) {
            data[i]=(int)(Math.random()*count);
        }
        return data;
    }
    public static void main(String[] args) {
        final int count=10000;
        int[] data=createDate(count);
        
        Thread qsort=new Thread(new QSort(data),"快速排序");
        int[] data2=new int[count];
        System.arraycopy(data,0,data2,0,count);
        Thread bsort=new Thread(new BSrot(data2),"冒泡排序");
        int[] data3=new int[count];
        System.arraycopy(data,0,data3,0,count);
        Thread bbsort=new Thread(new BBSort(data3),"雙向排序");
        qsort.start();
        bsort.start();
        bbsort.start();
    }
}

運行結果：

從結果來看 可以知道快速排序 效率更快！