java实现各种排序算法

主要实现了插入，冒泡，选择，归并，快速排序

代码如下：

package cn.com.cnn;
//从小到大的顺序
public class MySort {

    public static void main(String[] args) {
        int[] data = {3, 6, 4, 1, 5, 2};
        MySort mySort = new MySort();
        int[]  result1 = mySort.chooseSort(data);
        for(int i : result1) {
            System.out.print(i);
        }
        int[]  result2 = mySort.quickSort(data);
        for(int i : result2) {
            System.out.print(i);
        }
        int[]  result3 = mySort.insertSort(data);
        for(int i : result3) {
            System.out.print(i);
        }
        int[]  result4 = mySort.mergeSort(data);
        for(int i : result4) {
            System.out.print(i);
        }
        int[]  result5 = mySort.bubbleSort(data);
        for(int i : result5) {
            System.out.print(i);
        }

    }

    //插入排序
    public int[] insertSort(int[] data) {
        for(int i = 1; i < data.length; i++) {
            //0---j是现有的有序序列
            int j = i - 1;
            int temp = data[i];
            while(j >= 0 && temp < data[j]) {
                data[j + 1] = data[j];
                j--;        
            }
            data[j + 1] = temp;
        }
        return data;
    }

    //冒泡排序
    public int[] bubbleSort(int[] data) {
        for(int i = 1; i < data.length; i++) {
            for(int j = 0; j < data.length - i; j++) {
                if(data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }

        return data;
    }

    //选择排序
    public int[] chooseSort(int[] data) {
        for(int i = 0; i < data.length; i++) {
            int minIndex = i;
            for(int j = i + 1; j < data.length; j++) {
                //找[i+1,length]中的最小值
                if (data [j] < data[minIndex]) {
                    minIndex = j;
                }
            }
            int swap = data[i];
            data[i] = data[minIndex];
            data[minIndex] = swap;
        }

        return data;
    }

    //快速排序
    public int[] quickSort(int[] data) {

        int[] result = quickSortCore(data, 0, data.length - 1);

        return result;
    }
    public int[] quickSortCore(int[] data, int leftIndex, int rightIndex) {
        if(leftIndex >= rightIndex) {
            return null;
        }
        int i = leftIndex;
        int j =rightIndex;
        int centerNum = data[leftIndex];
        while(i < j) {
            while(i < j && data[j] >= centerNum) 
                j--;
            data[i] = data[j];
            while(i < j && data[i] <= centerNum)
                i++;
            data[j] = data[i];
        }
        data[j] = centerNum;
        quickSortCore(data, leftIndex, j - 1);
        quickSortCore(data, j + 1, rightIndex);

        return data;
    }


    //归并排序
    public int[] mergeSort(int data[]) {
        int middIndex = (data.length - 1) / 2;
        mergeSortCore(data, 0, middIndex);
        mergeSortCore(data, middIndex + 1, data.length - 1);
        merge(data, 0, middIndex, data.length - 1);

        return data;
    }

    public int[] mergeSortCore(int data[], int leftIndex, int rightIndex) {
        if(leftIndex < rightIndex) {
            int middIndex = (leftIndex + rightIndex) / 2;
            mergeSortCore(data, leftIndex, middIndex);
            mergeSortCore(data, middIndex + 1, rightIndex);
            merge(data, leftIndex, middIndex, rightIndex);
        }

        return data;
    }

    public int[] merge(int[] data, int leftIndex, int middIndex, int rightIndex) {
        int[] tempArr = new int[rightIndex - leftIndex + 1];
        int i = leftIndex;
        int j = middIndex + 1;
        int k = 0;
        while(i <= middIndex && j <= rightIndex) {
            if(data[i] < data[j]) {
                tempArr[k++] = data[i++];
            } else {
                tempArr[k++] = data[j++];
            }
        }
        //将剩余部分放回中间数组
        while(i <= middIndex) {
            tempArr[k++] = data[i++];
        }
        while(j <= rightIndex) {
            tempArr[k++] = data[j++];
        }
        int m = 0;
        while(leftIndex <= rightIndex) {
            data[leftIndex++] = tempArr[m++];
        }
        return data;
    }

}