快速排序
原理是找出一個元素（理論上可以隨便找一個）作爲基準(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");
}
}
}
QSortpackage 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
}
}
BSrot Codepackage 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;
}
}
}
}
}
BBSrot Codepackage 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();
}
}
MainTest Code運行結果：
從結果來看 可以知道快速排序 效率更快！
| 博客地址： | http://www.cnblogs.com/oumyye/ |
| 博客版權： | 本文以學習、研究和分享爲主，歡迎轉載，轉載請務必註明出處，謝謝合作。 如果文中有不妥或者錯誤的地方請指出。如果覺得本文對你有所幫助不如【推薦】一下！如果你有更好的建議，不如留言一起討論，共同進步！ |
