几个常用排序算法的实现

最近重温了下基础算法，不多说，直接贴代码。
本文的排序算法包含五种：冒泡排序，快速排序，简单选择排序，直接插入排序，希尔排序

    /**
     * 冒泡排序
     * @param nums
     * @return
     */
    private static int[] maoPaoSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
                if(nums[j] > nums[j+1]) {
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
            System.out.println(Arrays.toString(nums));
        }
        return nums;
    }

    /**
     * 快速排序
     * @param nums
     * @param left
     * @param right
     * @return
     */
    private static int[] quickSort(int[] nums, int left, int right) {
        if(left < right) {
            int x = nums[left], i = left, j = right;
            while (i < j) {
                while (i < j && nums[j] > x) {
                    j--;
                }
                if(i < j) {
                    nums[i] = nums[j];
                    i++;
                }

                while (i < j && nums[i] < x) {
                    i++;
                }
                if(i < j) {
                    nums[j] = nums[i];
                    j--;
                }
            }

            nums[i] = x;
            quickSort(nums, left, i - 1);
            quickSort(nums, i + 1, right);
        }
        return nums;
    }

    /**
     * 简单选择排序
     * @param nums
     * @return
     */
    private static int[] chooseSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            int min = i;
            for (int j = i+1; j < nums.length; j++) {
                if(nums[j] < nums[min]) {
                    min = j;
                }
            }
            if(i < min) {
                int temp = nums[i];
                nums[i] = nums[min];
                nums[min] = temp;
            }
            System.out.println(Arrays.toString(nums));
        }

        return nums;
    }

    /**
     * 插入排序
     * @param nums
     * @return
     */
    private static int[] insertSort(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            //第i个元素就是待插入的元素，与之逐个比较的是第0 ~ i-1个元素
            for (int j = i; j > 0 ; j--) {
                if(nums[j] < nums[j-1]) {
                    int temp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = temp;
                } else {
                    break;
                }
            }
            System.out.println(Arrays.toString(nums));
        }
        return nums;
    }

    /**
     * 希尔排序（优化版的插入排序，也称缩小增量排序，其实就是在直接插入排序的外层再加一层循环）
     * 本例中增量序列为1,2,4,8...2n...nums.length/2
     * @param nums
     * @return
     */
    private static int[] shellSort(int[] nums) {
        for (int gap = nums.length/2; gap > 0 ; gap/=2) {
            for (int i = gap; i < nums.length; i++) {
                for (int j = i; j >= gap ; j=j-gap) {
                    if(nums[j] < nums[j-gap]) {
                        int temp = nums[j];
                        nums[j] = nums[j-gap];
                        nums[j-gap] = temp;
                    } else {
                        break;
                    }
                }
            }
            System.out.println("gap==" + gap + ", sort:"+Arrays.toString(nums));
        }
        return nums;
    }

测试主程序：

import java.util.Arrays;

public class SortTest {
    private static int[] nums = {5,2,9,4,0,7,3,8,6,1};

    public static void main(String[] args) {
        System.out.println("nums:"+Arrays.toString(nums));
//        int[] result = maoPaoSort(nums);
//        int[] result = quickSort(nums, 0, nums.length-1);
//        int[] result = chooseSort(nums);
//        int[] result = insertSort(nums);
        int[] result = shellSort(nums);
        System.out.println("result:"+Arrays.toString(result));
    }
}