java中常見的排序算法

以下列出java中常用的幾種排序算法，只是簡單實現了排序的功能，還有待改進，望指教（以下均假設數組的長度爲n）：

1）冒泡排序：

依次比較相鄰的兩個元素，通過一次比較把未排序序列中最大（或最小）的元素放置在未排序序列的末尾。

 

public class BubbleSort {
    public static void sort(int data[]) {
        for (int i = 0; i < data.length -1; i++) {
            for (int j = 0; j < data.length - i - 1; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }

            }
        }
    }

}

 

 

2）選擇排序：

每一次從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。

 

public class SelectionSort {
    public static void sort(int data[]) {
        int minVal;
        int minIndex;
        for (int i = 0; i < data.length - 1; i++) {
            minVal = data[i];
            minIndex = i;
            for (int j = i + 1; j < data.length; j++) {
                if (data[j] < minVal) {
                    minVal = data[j];
                    minIndex = j;
                }
            }
            if (minVal != data[i] && minIndex != i) {
                data[minIndex] = data[i];
                data[i] = minVal;
            }
        }

    }

}

 

3）插入排序：

將數列分爲有序和無序兩個部分，每次處理就是將無序數列的第一個元素與有序數列的元素從後往前逐個進行比較，找出插入位置，將該元素插入到有序數列的合適位置中。

public class InsertionSort {
    public static void sort(int data[]) {
        for (int i = 1; i < data.length; i++) {
            for (int j = i; j > 0; j--) {
                if (data[j] < data[j - 1]) {
                    int temp = data[j];
                    data[j] = data[j - 1];
                    data[j - 1] = temp;
                }
            }
        }
    }
}

 

4）歸併排序：

將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分爲若干個子序列，每個子序列是有序的。然後再把有序子序列合併爲整體有序序列。排序過程如下：
（1）申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列
（2）設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置
（3）比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一位置
（4）重複步驟3直到某一指針達到序列尾
（5）將另一序列剩下的所有元素直接複製到合併序列尾

 

public class MergeSort {
    public static void sort(int data[], int start, int end) {
        if (start < end) {
            int mid = (start + end) / 2;
            sort(data, start, mid);
            sort(data, mid + 1, end);
            merge(data, start, mid, end);
        }
    }

    public static void merge(int data[], int start, int mid, int end) {
        int temp[] = new int[end - start + 1];
        int i = start;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= end) {
            if (data[i] < data[j]) {
                temp[k++] = data[i++];
            } else {
                temp[k++] = data[j++];
            }
        }

        while (i <= mid) {
            temp[k++] = data[i++];
        }
        while (j <= end) {
            temp[k++] = data[j++];
        }

        for (k = 0, i = start; k < temp.length; k++, i++) {
            data[i] = temp[k];
        }
    }

}

 

5）快速排序：

通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

 

public class QuickSort {
    public static void sort(int data[], int start, int end) {
        if (end - start <= 0) {
            return;
        }
        int last = start;
        for (int i = start + 1; i <= end; i++) {
            if (data[i] < data[start]) {
                int temp = data[++last];
                data[last] = data[i];
                data[i] = temp;
            }
        }
        int temp = data[last];
        data[last] = data[start];
        data[start] = temp;
        sort(data, start, last - 1);
        sort(data, last + 1, end);
    }

}