数组的各类排序

package sort;

/**
 * 数组的各种排序操作
 * Created by liuwei on 16/3/6.
 */
public class MSort {

    /**
     * 直接插入排序
     * 外层一个循环,从第2个元素开始(下标为1),遍历后面的所有元素
     * 内层一个循环,从当前位置position =i 开始,每次与position-1的元素对比
     *      如果当前元素小于position-1的元素,position--
     *      如果当前元素大于等于position-1的元素,说明position就是我们要插入的地方
     * 内层循环的中止条件:因为我们每次都是与position-1做对比的,显然position>=1
     *
     * check下:
     *      当position==1的时候,进入while循环,
     *      如果当前元素大于等于下标为0的元素,直接break position=1
     *      如果当前元素小于下标为0的元素,position-- position=0 然后不满足循环条件,退出
     * */
    public static void straightInsertionSort(int[] nums){
        if(nums == null) return;
        for(int i=1; i < nums.length; i++){
            int position = i;
            while(position >=1){
                if(nums[i] < nums[position - 1]){
                    position --;
                }
                else{
                    break;
                }
            }
            int tmp = nums[i];
            for(int j = i; j>position;j--){
                nums[j] = nums[j-1];
            }
            nums[position] = tmp;
        }
    }

    /**
     * 冒泡排序
     * 冒泡排序每次将最大的沉到最后面,每次确定一个最大的,
     * 因此,在内层循环的时候,每次实际需要遍历的个数-1
     * */
    public static void bubbleSort(int[] nums){
        if(nums == null) return;
        for(int i=1; i < nums.length; i++){
            for(int j = 0; j < nums.length - i; j++ ){
                if(nums[j] > nums[j+1]){
                    int tmp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = tmp;
                }
            }
        }
    }

    /**
     * 快速排序
     * 快排的基本思想是选择一个标杆元素,将比标杆元素大的放置在它的后面,将比它小的放在它前面
     * 这样,我们就把原先的数组分成两部分,左边那部分全部比标杆元素小,右边那部分全部比标杆元素大
     * 这样,我们只要递归的处理左右两部分即可
     * */
    public static void quickSort(int[] nums,int left,int right){
        if(left < right){
            int flag = partition(nums,left,right);
            quickSort(nums,left,flag-1);
            quickSort(nums,flag+1,right);
        }
    }

    private static int partition(int[] nums, int left, int right) {
        int pivotekey = nums[left];
        while(left < right){
            while(left < right && nums[right] >= pivotekey) right --;
            nums[left] = nums[right];
            while(left < right && nums[left] <= pivotekey) left ++;
            nums[right] = nums[left];
        }
        nums[left] = pivotekey;
        return left;
    }


    /**
     * 选择排序
     * 简单选择排序的基本思想就是每次选择最大或者最小的放在最后面或者最前面的位置
     * */
    public static void simpleSelectionSort(int[] nums){
        if(nums == null) return;
        for(int i=1; i < nums.length;i++){
            int maxIndex = 0;
            for(int j=0;j <= nums.length - i;j++){
                if(nums[j] > nums[maxIndex]){
                    maxIndex = j;
                }
            }
            int tmp = nums[maxIndex];
            nums[maxIndex] = nums[nums.length - i];
            nums[nums.length - i] = tmp;
        }
    }

    /**
     * 归并排序
     * 归并排序最本质的思想是利用两个有序数组O(m+n)时间复杂度的合并
     * 但是,有个前提,必须是有序数组,但是给的肯定只有一个待排序的无序数组,怎么构成有序呢?
     * 因此,这里就需要划分,当划分成n份,每个小组只有一个元素,这时候,再选出两组,一合并就是有序的了,以此类推
     * */
    public static void mergingSort(int[] nums,int left,int right){
        if(left < right){
            int mid = left + (right - left) / 2;
            mergingSort(nums,left,mid);
            mergingSort(nums,mid+1,right);
            merge(nums,left,mid,right);
        }
    }

    private static void merge(int[] nums, int left, int mid, int right) {
        int[] tmps = new int[right - left + 1];
        int i = left,j = mid+1;
        int k = 0;
        while(i<=mid && j <=right){
            if(nums[i] <= nums[j]){
                tmps[k++] = nums[i];
                i++;
            }
            else{
                tmps[k++] = nums[j];
                j++;
            }
        }
        while(i<=mid){
            tmps[k++] = nums[i];
            i++;
        }
        while(j<=right){
            tmps[k++] = nums[j];
            j++;
        }
        for(k=left; k<=right; k++){
            nums[k] = tmps[k - left];
        }
    }

    private static void show(int[] nums){
        for(Integer i : nums){
            System.out.print(i+" ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] nums = {1,3,5,7,9,0,8,6,4,2};
//        int[] nums = {14,49,38,65,97,76,13,27};
//        bubbleSort(nums);
//        straightInsertionSort(nums);
//        quickSort(nums,0,nums.length-1);
//        simpleSelectionSort(nums);
        mergingSort(nums,0,nums.length -1);
        show(nums);
    }
}