排序算法（冒泡、选择、插入、希尔、快排、归并）（Java实现）

排序算法（冒泡、选择、插入、希尔、快排、归并）

package cn.kales.algorithm.test.test01;

public class Sort {

    //冒泡排序
    public void BubbleSort(int[] A){
        int len = A.length;
        for (int i = 0;i<len;i++){
            int flag = 0;
            for (int j = 0;j<len-i-1;j++){
                int temp;
                if (A[j] > A[j+1]){
                    temp = A[j+1];
                    A[j+1] = A[j];
                    A[j] = temp;
                    flag = 1;
                }
            }
            if (flag == 0){
                break;
            }
        }
    }

    //选择排序
    public void SelectSort(int[] A){
        for (int i = 0;i< A.length-1;i++){
            int minIndex = i;
            for (int j = i+1;j<A.length;j++){
                if (A[j] < A[minIndex]){
                    minIndex = j;
                }
            }
            if (minIndex != i){
                int temp;
                temp = A[i];
                A[i] = A[minIndex];
                A[minIndex] = temp;
            }
        }
    }

    //插入排序
    public void InsertSort(int[] A){
        int len = A.length;
        for (int i = 1;i<len;i++){
            for (int j = i-1;j>=0;j--){
                if (A[i] < A[j]){
                    int temp;
                    temp = A[i];
                    A[i] = A[j];
                    A[j] = temp;
                }
            }
        }
    }

    //希尔排序
    public void ShellSort(int[] A){
        int len = A.length;
        //增量的变化
        for (int gap = len/2;gap>0;gap/=2){
            //对增量分组后的数组进行插入排序
            for (int i = gap;i<len;i++){
                while(i-gap >= 0 && A[i] < A[i-gap]){
                    int temp = A[i];
                    A[i] = A[i-gap];
                    A[i-gap] = temp;
                }
            }
        }
    }

    //快速排序
    public void QuickSort(int[] arr,int left,int right){
        int key = arr[left];    //以key为基准，，将数组分为两部分
        int i = left;
        int j = right;

        while(i<j){
            while(i<j && arr[j] >= key) j--; //j向前扫描，，若出现比key小的值，与arr[i]替换，i+1；
                                            //此时的arr[i]为key值，因此可以直接覆盖
            if (i<j) {
                arr[i] = arr[j];
                i++;
            }

            while(i<j && arr[i] <= key) i++;  //i向后扫描，，若出现比key大的值，与arr[j]替换，j--；
                                            //此时的arr[j]原值已经替换到i之前的位置，因此可以直接覆盖
            if (i<j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //i=j时，一趟快排结束，，将key值赋给arr[i]  或者 arr[j]
        arr[i] = key;
        QuickSort(arr,left,i-1);
        QuickSort(arr,i+1,right);
    }

    //归并排序
    public void MergeSort(int[] arr ,int left,int right,int[] temp){
        //将待排序数组进行分解
        if (left<right){
            int mid = (left+right)/2;
            MergeSort(arr,left,mid,temp);
            MergeSort(arr,mid+1,right,temp);

            merge(arr,left,mid,right,temp);
        }
    }


    //两段数组合并排序的过程
    public void merge(int[] arr,int left,int mid,int right,int[] temp){
        //两段数组，分别以i和j为开始，以mid和right为结尾
        int i = left;
        int j = mid+1;
        int t = 0;

        //注意：：从单个元素合并开始，，每一段数组都是有序的
        //将两段数组 按从小到大的顺序加入到临时数组temp中
        while(i<=mid && j<=right){
            if (arr[i] <= arr[j])
                temp[t++] = arr[i++];
            else
                temp[t++] = arr[j++];
        }

        //对于剩余未加入的数组元素，按顺序加入到临时数组中
        while(i<=mid) temp[t++] = arr[i++];
        while(j<=right) temp[t++] = arr[j++];

        //将临时数组中的已经排完序的元素，替换到原数组的对应位置

        for (int start = 0;start < temp.length;start++){
            arr[left++] = temp[start];
        }

    }
}