基於JAVA實現的排序演算法總結

標籤：int   bsp   amp   java   ted   []   html   合并   總結   

　　常用的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、歸併排序，除此之外，還有基數排序、雞尾酒排序、桶排序、鴿巢排序、希爾排序等，這裡著重介紹下前半段列舉的幾種常見方法的實現。

　　1. 冒泡排序法：

/* * 1.比較相鄰元素：如果第一個比第二個大，就交換 * 2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對 * 3.針對所有的元素重複以上的步驟，除了最後一個 */public class Bubble {    public static int[] sort(int[] data){        int temp;        int size = data.length;        for(int i=0;i<size-1;i++){            for(int j=i+1;j<size;j++){                if(data[i] > data[j]){                    temp = data[i];                    data[i] = data[j];                    data[j] = temp;                }            }        }        return data;    }}

　　2. 快速排序法:

/* * 1.從數列中挑出一個基準值 * 2.重新排序數列，比基準值小的元素放在基準前，比基準值大的放在基準後，相同的可放到任一邊 * 3.遞迴進行如上操作 */public class Quick {    public static int[] sort(int[] data, int start, int end){        if(start < end){            int base = data[start];            int temp;            int i=start,j=end;            do {                while ((data[i] < base) && (i < end))                    i++;                while ((data[j] > base) && (j > start))                    j--;                if(i <= j){                    temp = data[i];                    data[i] = data[j];                    data[j] = temp;                    i++;                    j--;                }            }while (i<=j);            if(start < j){                sort(data,start,j);            }            if(end > i){                sort(data,i,end);            }        }        return data;    }}

　　3. 選擇排序法：每次尋找序列中的最小值，然後放在最末尾的位置。

/* *1.在未排序序列中找到最小元素，存放到排序序列的起始位置 *2.再從剩餘未排序元素中繼續尋找最小元素，然後放到排序序列末尾 *3.以此類推，直到所有元素均排序完畢 */public class Select {    public static int[] sort(int[] data){        int temp;        int size = data.length;        for (int i = 0; i < size; i++) {            int k = i;            for (int j = size - 1; j >i; j--)  {                if (data[j] < data[k])                    k = j;            }            temp = data[i];            data[i] = data[k];            data[k] = temp;        }        return data;    }}

　　4. 插入排序法：通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。

/* * 1.從第一個元素開始，取出下一個元素，在已經排序的元素序列中從後向前掃描,如果該元素（已排序）大於新元素，將該元素移到下一位置 * 2.重複1，直到找到已排序的元素小於或者等於新元素的位置 * 3.將新元素插入到該位置中 * 4.重複步驟2-3 */public class Insert {    public static int[] sort(int[] data) {        int size = data.length;        int temp;        int j;        for (int i = 1; i < size; i++) {            temp = data[i];            for (j = i; j > 0 && temp < data[j - 1]; j--)                data[j] = data[j - 1];            data[j] = temp;        }        return data;    }}

　　5. 歸併排序法：

/* * 1.申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并後的序列 * 2.設定兩個指標，最初位置分別為兩個已經排序序列的起始位置 * 3.比較兩個指標所指向的元素，選擇相對小的元素放入到合并空間，並移動指標到下一位置 * 4.重複步驟3直到某一指標達到序列尾 * 5.將另一序列剩下的所有元素直接複製到定序序列尾 */public class Merge{    public static int[] sort(int[] data,int left, int right){        int t = 1;        int size = right - left + 1;        while (t < size) {            int s = t;            t = 2 * s;            int i = left;            while (i + (t - 1) < size) {                merge(data, i, i + (s - 1), i + (t - 1));                i += t;            }            if (i + (s - 1) < right)                merge(data, i, i + (s - 1), right);        }        return data;    }    private static void merge(int[] data, int p, int q, int r) {        int[] B = new int[data.length];        int s = p;        int t = q + 1;        int k = p;        while (s <= q && t <= r) {            if (data[s] <= data[t]) {                B[k] = data[s];                s++;            } else {                B[k] = data[t];                t++;            }            k++;        }        if (s == q + 1)            B[k++] = data[t++];        else            B[k++] = data[s++];        for (int i = p; i <= r; i++)            data[i] = B[i];    }}

　　6. 測試代碼：

public class SortMethodTest {    public static void main(String[] args) {        int[] data = new int[6];        data[0] = 15;        data[1] = 23;        data[2] = 8;        data[3] = 19;        data[4] = 21;        data[5] = 8;        System.out.println("排序前:"+data[0]+","+data[1]+","+data[2]+","+data[3]+","+data[4]+","+data[5]);        //冒泡法        int [] afterBubbleSortedData = Bubble.sort(data);        System.out.println("冒泡排序法排序後:"+afterBubbleSortedData[0]+","+afterBubbleSortedData[1]+","+afterBubbleSortedData[2]+","+afterBubbleSortedData[3]+","+afterBubbleSortedData[4]+","+afterBubbleSortedData[5]);        //快速排序法        int[] afterQuickSortedData = Quick.sort(data,0,4);        System.out.println("快速排序法排序後:"+afterQuickSortedData[0]+","+afterQuickSortedData[1]+","+afterQuickSortedData[2]+","+afterQuickSortedData[3]+","+afterQuickSortedData[4]+","+afterQuickSortedData[5]);        //選擇排序法        int[] afterSelectSortedData = Select.sort(data);        System.out.println("選擇排序法排序後:"+afterSelectSortedData[0]+","+afterSelectSortedData[1]+","+afterSelectSortedData[2]+","+afterSelectSortedData[3]+","+afterSelectSortedData[4]+","+afterSelectSortedData[5]);        //插入排序法        int[] afterInsertSortedData = Insert.sort(data);        System.out.println("插入排序法排序後:"+afterInsertSortedData[0]+","+afterInsertSortedData[1]+","+afterInsertSortedData[2]+","+afterInsertSortedData[3]+","+afterInsertSortedData[4]+","+afterInsertSortedData[5]);        //歸併排序法        int[] afterMergeSortedData = Merge.sort(data,0,1);        System.out.println("歸併排序法排序後:"+afterMergeSortedData[0]+","+afterMergeSortedData[1]+","+afterMergeSortedData[2]+","+afterMergeSortedData[3]+","+afterMergeSortedData[4]+","+afterMergeSortedData[5]);    }}

測試結果：

排序前:15,23,8,19,21,8
冒泡排序法排序後:8,8,15,19,21,23
快速排序法排序後:8,8,15,19,21,23
選擇排序法排序後:8,8,15,19,21,23
插入排序法排序後:8,8,15,19,21,23
歸併排序法排序後:8,8,15,19,21,23

 

轉自：http://www.cnblogs.com/sevenyuan/archive/2009/12/04/1616897.html

基於JAVA實現的排序演算法總結