排序系列--代码版

参照： 对线面试官
公共输出代码：

public  static void printNums(int[] nums){
        for(int num : nums)
            System.out.print(num+"->");
        System.out.println("\n");
    }

冒泡

public  static void bubbleSort(int[] nums) {
        boolean flag_swap;
        for(int i = 0; i < nums.length - 1; i++){
            flag_swap = false;
            for(int j = 1; j < nums.length -i; j++){
                //swap
                if(nums[ j - 1] > nums[j]){
                    nums[j] = nums[j-1] + nums[j];
                    nums[j - 1] = nums[j] -nums[j - 1];
                    nums[j] = nums[j] -nums[j - 1];
                }
                flag_swap = true;
            }

            if(!flag_swap)
                break;
        }
        System.out.println("冒泡");
        printNums(nums);
    }

选择

public  static void selectSort(int[] nums) {
        int flag_swap;
        for(int i = 0; i < nums.length - 1; i++){
            flag_swap = i;
            for(int j = i + 1; j < nums.length ; j++){
                //标记下标
                if(nums[j] < nums[flag_swap]){
                    flag_swap = j;

                }

            }
            if(flag_swap != i){
                nums[i] = nums[flag_swap] + nums[i];
                nums[flag_swap] = nums[i] -nums[flag_swap];
                nums[i] = nums[i] -nums[flag_swap];
            }
        }
        System.out.println("选择");
        printNums(nums);
    }

插入

public  static void insertSort(int[] nums) {
        int flag_swap;
        for(int i = 1; i < nums.length; i++){
            //标记下标和值
            int temp = nums[i];
            flag_swap = i-1;

            //下标合法且要后移
            while( flag_swap >= 0  && nums[flag_swap] > temp){
                nums[flag_swap +1] = nums[flag_swap];
                flag_swap --;
            }
            nums[flag_swap + 1] = temp;
        }
        System.out.println("插入");
        printNums(nums);
    }

快排

 public  static void quickSort(int[] nums, int L, int R) {

        int left = L, right = R;
        int mid = left + (right - left) / 2;
        while(left <= right){
            while(left <= right && nums[right] > nums[mid])
                right--;
            while(left <= right && nums[left] < nums[mid])
                left++;
            if(left <= right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left ++;
                right --;
            }
        }

        if(left <= R)
            quickSort(nums, left, R);

        if(right > L)
            quickSort(nums, L, right);

        //System.out.println("快速");
        //printNums(nums);
    }

合并

//不断二分
public  static void mergeSort(int[] nums, int L, int R) {
        if( L == R){
            return;
        }else {
            int M = L + (R - L) / 2;
            mergeSort(nums, L, M);
            mergeSort(nums, M+1, R); //注意[L, M] [M + 1, R]
            mergeNums(nums, L, M+1, R);
        }

        //System.out.println("快速");
        //printNums(nums);
    }

    private   static void mergeNums(int[] nums, int L, int M, int R) {

        int[] nums1 = new int[M - L];
        int[] nums2 = new int[R - M + 1];

        //往这两个数组填充数据
        for (int i = L; i < M; i++) {
            nums1[i - L] = nums[i];
        }
        //i <= R  这个等号很关键
        for (int i = M; i <= R; i++) {
            nums2[i - M] = nums[i];
        }
        int i = 0, j = 0, k = L;
        while(i < nums1.length  && j < nums2.length){
            if(nums1[i] <= nums2[j] ) {
                nums[k] = nums1[i];
                i++;
            }else{
                nums[k] = nums2[j];
                j++;
            }
            k++;

        }

        while(i < nums1.length) {
            nums[k] = nums1[i];
            i++;
            k++;
        }

        while(j < nums2.length) {
            nums[k] = nums2[j];
            j++;
            k++;
        }
    }

堆

public  static void heapifySort(int[] nums) {
        if(nums == null || nums.length == 0 )
            return;
        int len = nums.length;
        createMaxHeap(nums, len);
		//回收
        for(int i = nums.length - 1; i > 0; i --){
            int temp = nums[i];
            nums[i] = nums[0];
            nums[0] = temp;
            len --;
            heapify(nums,0,len);
        }

    }

	//建堆
    private  static void createMaxHeap(int[] nums, int len) {

        for (int i = len / 2 ; i >= 0; i--) {
            heapify(nums, i, len);
        }
    }
	//堆化
    private  static void heapify(int[] nums, int index, int length) {

        int left = 2 * index, right = 2 * index + 1;
        int largeIndex = index;

        if(left < length && nums[left] > nums[largeIndex])
            largeIndex = left;

        if(right < length && nums[right] > nums[largeIndex])
            largeIndex = right;

        if(largeIndex != index){
            int temp = nums[largeIndex];
            nums[largeIndex] = nums[index];
            nums[index] = temp;
            heapify(nums, largeIndex ,length);
        }
    }

希尔

public static void shellSort(int[] nums) {
		//参照插入排序
        for(int step = nums.length / 2; step > 0; step /= 2){
			
            for(int i = step; i < nums.length; i++) {
                int j = i;
                int temp = nums[j];
                while(j - step >= 0  && nums[j - step] > temp) {
                    nums[j] = nums[j - step];
                    j -= step;
                }
                nums[j] = temp;
            }
        }
        System.out.println("希尔");
        printNums(nums);
    }

桶

 public static void bucketSort(int[] nums) {

        int max = findMax(nums, 0 ,nums.length - 1);
        //最大数决定循环次数
        for(int step = 1; max / step > 0; step *= 10){
            int[][] bucket = new int[nums.length][10];
            for(int i = 0; i < nums.length; i++) {
                int j = (nums[i] / step) % 10;
                bucket[i][j] = nums[i];
            }
            //收桶
            //注意循环的顺序
            int k = 0;
            for(int j = 0; j < 10; j++){
                for(int i = 0; i < nums.length; i++){
                    if(bucket[i][j] != 0){
                        nums[k ++] = bucket[i][j];
                    }
                }
            }
        }

        System.out.println("桶");
        printNums(nums);
    }
	//递归寻找
    public  static int findMax(int[] nums, int L, int R) {
        if(L == R){
            return nums[L];
        }else{
            int a = nums[L];
            int b = findMax(nums, L + 1, R);
            return Math.max(a, b);
        }
    }

总结下来就是，眼过千遍不如手过一遍。