排序算法java版

排序是非常常見的問題，將簡單實現9大排序算法
1、創建BaseSort.java

package com.csh.sort;

public abstract class BaseSort {

    protected int data[];
    protected int length;

    public BaseSort(int data[]) {
        this.data = data;
        this.length = this.data.length;
    }

    public final void dispaly() {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            sb.append(data[i]);
            if (i != length - 1) {
                sb.append(",");
            }
        }
        System.out.println(sb.toString());
    }

    protected void swap(int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    public abstract void sort();

}

下面的排序都將繼承此類去實現
2、冒泡排序法BubbleSort.java

package com.csh.sort;

/*
 * 冒泡排序法
 */
public class BubbleSort extends BaseSort {

    public BubbleSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        // 標記是否有交換數據
        boolean flag = true;
        for (int i = 0; i < length && flag; i++) {
            flag = false;
            for (int j = length - 1; j > i; j--) {
                if (data[j] < data[j - 1]) {
                    swap(j, j - 1);

                    flag = true;
                }
            }
        }
    }

}

3、桶式排序BucketSort.java

package com.csh.sort;

/*
 * 桶式排序
 * （1）對於這個可枚舉範圍構建一個buckets數組，用於記錄“落入”每個桶中元素的個數；
（2）將（1）中得到的buckets數組重新進行計算，按如下公式重新計算：
buckets[i] = buckets[i] +buckets[i-1] (其中1<=i<buckets.length); 
 */
public class BucketSort extends BaseSort {

    public BucketSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        int[] mm = getMaxMin();
        int max = mm[0];
        int min = mm[1];
        // 緩存數組
        int[] tmp = new int[length];
        // buckets用於記錄待排序元素的信息
        // buckets數組定義了max-min個桶
        int[] buckets = new int[max - min];
        // 計算每個元素在序列出現的次數
        for (int i = 0; i < length; i++) {
            buckets[data[i] - min]++;
        }
        // 計算“落入”各桶內的元素在有序序列中的位置
        for (int i = 1; i < max - min; i++) {
            buckets[i] = buckets[i] + buckets[i - 1];
        }
        // 將data中的元素完全複製到tmp數組中
        System.arraycopy(data, 0, tmp, 0, data.length);
        // 根據buckets數組中的信息將待排序列的各元素放入相應位置
        for (int k = data.length - 1; k >= 0; k--) {
            data[--buckets[tmp[k] - min]] = tmp[k];
        }
    }

    // 取出最大值，最小值
    private int[] getMaxMin() {
        int mm[] = new int[2];
        mm[0] = data[0];
        mm[1] = data[1];
        for (int i = 1; i < length; i++) {
            if (data[i] > mm[0]) {
                mm[0] = data[i];
            }
            if (data[i] < mm[0]) {
                mm[1] = data[i];
            }
        }

        return mm;
    }

}

4、堆排序HeapSort.java

package com.csh.sort;

/*
 * 堆排序
 */
public class HeapSort extends BaseSort {

    public HeapSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        dispaly();
        for (int i = 0; i < length; i++) {
            createMaxdHeap(length - 1 - i);
            swap(0, length - 1 - i);
            System.out.print(i+"=");
            dispaly();
        }
    }

    private void createMaxdHeap(int lastIndex) {
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // 保存當前正在判斷的節點
            int k = i;
            // 若當前節點的子節點存在
            while (2 * k + 1 <= lastIndex) {
                // biggerIndex總是記錄較大節點的值,
                // 先賦值爲當前判斷節點的左子節點
                int biggerIndex = 2 * k + 1;
                if (biggerIndex < lastIndex) {
                    // 若右子節點存在，
                    // 否則此時biggerIndex應該等於 lastIndex
                    if (data[biggerIndex] < data[biggerIndex + 1]) {
                        // 若右子節點值比左子節點值大，
                        // 則biggerIndex記錄的是右子節點的值
                        biggerIndex++;
                    }
                }
                if (data[k] < data[biggerIndex]) {
                    k = biggerIndex;
                } else {
                    break;
                }
            }
            if (i != k) {
                swap(k, i);
            }
        }
    }

}

5、歸併排序MergingSort.java

package com.csh.sort;

/*
 *  歸併排序
 */
public class MergingSort extends BaseSort {

    public MergingSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        sortF(0, length - 1);
    }

    private void sortF(int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左邊
            sortF(low, mid);
            // 右邊
            sortF(mid + 1, high);
            // 左右歸併
            merge(low, mid, high);
        }
    }

    private void merge(int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;// 左指針
        int j = mid + 1;// 右指針
        int k = 0;

        // 把較小的數先移到新數組中
        while (i <= mid && j <= high) {
            if (data[i] < data[j]) {
                temp[k++] = data[i++];
            } else {
                temp[k++] = data[j++];
            }
        }

        // 把左邊剩餘的數移入數組
        while (i <= mid) {
            temp[k++] = data[i++];
        }

        // 把右邊邊剩餘的數移入數組
        while (j <= high) {
            temp[k++] = data[j++];
        }

        // 把新數組中的數覆蓋nums數組
        for (int k2 = 0; k2 < temp.length; k2++) {
            data[k2 + low] = temp[k2];
        }
    }

}

6、快速排序QuickSort.java

package com.csh.sort;

/*
 * 快速排序
 */
public class QuickSort extends BaseSort {

    public QuickSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        sortF(0, length - 1);
    }

    private void sortF(int low, int high) {
        int pivot;
        if (low < high) {
            pivot = partition(low, high);
            sortF(low, pivot - 1);
            sortF(pivot + 1, high);
        }
    }

    private int partition(int low, int high) {
        int pivotkey;

        // 優化點
        int m = low + (high - low) / 2;
        //保證左右中的左端最小
        if (data[low] > data[high]) {
            sortF(low, high);
        }
        if (data[m] > data[high]) {
            sortF(m, high);
        }
        if (data[m] > data[low]) {
            sortF(m, low);
        }

        pivotkey = data[low];
        while (low < high) {
            // 重表的兩端像中間掃描
            while (low < high && data[high] >= pivotkey) {
                high--;
            }
            if (low != high) {
                swap(low, high);
            }
            while (low < high && data[low] <= pivotkey) {
                low++;
            }
            if (low != high) {
                swap(low, high);
            }
        }

        return low;
    }

}

7、基數排序

package com.csh.sort;

/*
 * 基數排序
 * 基數排序(Radix sort)是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然後按每個位數分別比較。
 * 基數排序的方式可以採用LSD（Least significantdigital）或MSD（Most significantdigital），
 * LSD的排序方式由鍵值的最右邊開始，
 * 而MSD則相反，由鍵值的最左邊開始。
 */
public class RadixSort extends BaseSort {

    public RadixSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        lsd();
    }

    // LSD
    private void lsd() {
        int k = 0;
        int n = 1;
        int m = 1;

        int[][] temp = new int[length][length];
        int[] order = new int[length];

        while (m > 0) {
            m = 0;
            for (int i = 0; i < length; i++) {
                int lsd = ((data[i] / n) % 10);
                temp[lsd][order[lsd]] = data[i];
                order[lsd]++;
                if (data[i] / n > 10) {
                    m++;
                }
            }

            for (int i = 0; i < length; i++) {
                if (order[i] != 0)
                    for (int j = 0; j < order[i]; j++) {
                        data[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }

            n *= 10;
            k = 0;
        }
    }
}

8、希爾排序ShellSort.java

package com.csh.sort;

/*
 * 希爾排序
 */
public class ShellSort extends BaseSort {

    public ShellSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        // 步長
        for (int gap = length / 2; gap > 0; gap /= 2) {
            for (int j = gap; j < length; j += gap) {
                // 從數組第gap個元素開始
                if (data[j] < data[j - gap])// 每個元素與自己組內的數據進行直接插入排序
                {
                    int temp = data[j];
                    int k = j - gap;
                    while (k >= 0 && data[k] > temp) {
                        data[k + gap] = data[k];
                        k -= gap;
                    }
                    data[k + gap] = temp;
                }
            }
        }
    }

}

8、簡單選擇排序SimpleSelectionSort.java

package com.csh.sort;

/*
 * 簡單選擇排序
 */
public class SimpleSelectionSort extends BaseSort {

    public SimpleSelectionSort(int[] data) {
        super(data);
    }

    @Override
    public void sort() {
        // TODO Auto-generated method stub
        // 最小值座標
        int min = 0;
        for (int i = 0; i < length; i++) {
            min = i;
            for (int j = i + 1; j < length; j++) {
                if (data[j] < data[min])
                    min = j;
            }
            if (min != i) {
                swap(min, i);
            }
        }
    }

}

9、直接插入排序StraightInsertionSort.java

package com.csh.sort;

/*
 * 直接插入排序
 */
public class StraightInsertionSort extends BaseSort {

    public StraightInsertionSort(int[] data) {
        super(data);
    }

    /*
     * 長度必須大於1
     */
    @Override
    public void sort() {
        // TODO Auto-generated method stub
        int temp = 0;
        for (int i = 1; i < length; i++) {
            if (data[i] < data[i - 1]) {
                temp = data[i];
                int j;
                for (j = i - 1; j >= 0 && data[j] > temp; j--) {
                    data[j + 1] = data[j];
                }
                data[j + 1] = temp;
            }
        }
    }

}

10、測試類

package com.csh.sort;

public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int data[] = { 10, 1, 4, 54, 123, 456, 78, 89, 23, 34, 65, 2, 43, 56,
                100, 3, 4, 50 };
        // BaseSort sort=new BubbleSort(data);
        // BaseSort sort = new SimpleSelectionSort(data);
        // BaseSort sort = new StraightInsertionSort(data);
        // BaseSort sort = new ShellSort(data);
        // BaseSort sort = new HeapSort(data);
        // BaseSort sort = new MergingSort(data);
        // BaseSort sort = new QuickSort(data);
        // BaseSort sort = new BubbleSort(data);
        BaseSort sort = new RadixSort(data);
        sort.sort();
        sort.dispaly();
    }

}

以上代碼僅僅測試了其中的一種！
源碼下載地址[http://download.csdn.net/detail/u010154424/9483067](http://download.csdn.net/detail/u010154424/9483067