常见排序算法的JAVA实现方式(冒泡、希尔、快速、选择、插入)

以下代码包含：

  冒泡排序、希尔排序、快速排序、选择排序、插入排序，均默认从小到大排序

冒泡思路：
从左到右，将n个元素的第一个元素与右手元素相比较，比它大就交换位置，比它小就让它和它右手的元素继续比较下去，直至最右边，后边界长度减1，循环反复n-1次；
希尔思路：
n个元素，第一趟组间距离设置为n/2，这里用gap表示，即第0个元素与第0+gap+gap…(直到超过n)个元素进行比较大小，比较过程使用插入排序；第二趟组间距离设置为gap/2,将第0、0+gap、0+gap+gap…(直到超过n)，同样进行组间插入排序比较；循环反复 直至排序完成
快排思路：
对于长度为n的数组，设置i、j俩索引

• 从左手i开始向右，与j进行比较，如果比j大就，交换i j的值，i索引位置不变，j–；
• 如果i<=j，则i继续向右，i++；
• 直到i 和 j的索引重合 此时该索引左边的所有值小于该索引值，该索引右边的值大于该索引值
• 将数组进行左右分区，并对分区进行同样的i j移动比较排序，重复至排序完成

选择思路：
设置临时索引变量index，index索引位置从数组左边第一个元素开始，向右比较，如果找到比index索引对应的值小的元素，交换索引，一趟结束，将第一个元素的值与index索引对应的值进行交换；index索引移动至第二个元素，继续与右边所有元素比较，然后交换，直至排序结束。
插入排序：
假设数组从左往右第一个元素是有序的，从第二个元素开始，与第一个有序元素进行比较，比它小就移动到它左边，然后第三个元素继续与左边排序好的两个比较，找到要插入的位置，然后插入，直至排序结束。

public class SortWays {
    public static void main(String[] args) {
        int[] nums = new int[10];
        for (int i = 0; i < 10; i++) {
            nums[i] = (int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(nums));
//        冒泡排序
//        bubbleSort(nums);
//        选择排序
//        selectSort(nums);
//        插入排序
//        insertSort(nums);
//        快速排序
        quickSort(nums);
//		  希尔排序
//		  shellSort(nums);
//        System.out.println(Arrays.toString(nums));
    }

    /**
     * 堆排序 从小到大
     * @param nums
     */
    private static void heapSort(int[] nums) {

    }

    /**
     * 归并排序 从小到大
     * @param nums
     */
    private static void mergeSort(int[] nums) {

    }

    /**
     * 希尔排序 从小到大
     * @param nums
     */
    private static void shellSort(int[] nums) {
        if (nums == null || nums.length < 2) { return; }
        int gap = nums.length / 2;
        while (gap != 0) {
            // 组间进行直接插入排序
            for (int i = gap; i < nums.length; i++) {
                int value = nums[i];
                int j = i - gap;
                while (j >= 0 && nums[j] > value) {
                    nums[j + gap] = nums[j];
                    j = j - gap;
                }
                //因为while循环判断前减了依次gap，所以实际找到的点要加回去
                nums[j + gap] = value;
            }
            // 缩小增量
            gap = gap / 2;
        }
    }
    **
     * 快速排序
     * @param nums 待排序数组
     */
    private static void quickSort(int[] nums) {
        //空数组或者数组长度为1  直接返回
        if( nums == null || nums.length < 2 ) { return; }
        //给定原始数组左索引和右索引
        int leftBegin = 0;
        int rightEnd = nums.length-1;
        //需要用到递归  所以单独抽出方法 方便调用  传入数组及左右索引
        middleTool(nums, leftBegin, rightEnd);
    }

    /**
     * 递归方法体
     * @param nums
     * @param leftBegin
     * @param rightEnd
     */
    private static void middleTool(int[] nums, int leftBegin, int rightEnd) {
        //递归出口
        if(leftBegin >= rightEnd) { return; }
        //查看递归中间环节数组变化情况
        System.out.println(Arrays.toString(nums));
        //判断分区索引
        int partionIndex = judgePartIndex(nums, leftBegin, rightEnd);
        //左区间排序
        middleTool(nums,leftBegin,partionIndex-1);
        //右区间排序
        middleTool(nums,partionIndex+1,rightEnd);
    }

    /**
     * 判断分区点索引方法
     * @param nums 原始数组
     * @param left 数组区间左索引 闭区间
     * @param right 数组区间右索引 闭区间
     * @return 返回left/right都可以 两个都相等了 分区点索引
     */
    private static int judgePartIndex(int[] nums, int left, int right) {
        while (left < right) {
            //以下两个循环主要区别就是left->right和right->left
            //左索引开始与右索引进行比较 并根据结果判断是否向右移动
            while(nums[left] <= nums[right] && left < right){
                //两个循环的主要区别
                left++;
            }
            int temp1 = nums[left];
            nums[left] = nums[right];
            nums[right] = temp1;
            //右索引开始与左索引进行比较 并根据结果判断是否向左移动
            while(nums[right] >= nums[left] && right > left) {
                //两个循环的主要区别
                right--;
            }
            int temp2 = nums[right];
            nums[right] = nums[left];
            nums[left] = temp2;
        }
        //到这说明已经跳出上面while循环 即left=right  返回任意一个都行
        return left;
    }

    /**
     * 插入排序 从小到大
     * @param nums 随机生成待排序数组
     */
    public static void insertSort(int[] nums) {
        if(nums == null||nums.length<2){ return; }
        //范围1-size 逐个比较
        int i = 0,j = 0;
        for (i = 1; i < nums.length; i++) {
            //依次与左边已排序好的几个进行比较
            int temp = nums[i];
            //依次比较 比temp小就右移 直到找到temp的位置停止
            for (j = i; j > 0 && temp<nums[j-1]; j--) {
                nums[j] = nums[j-1];
            }
            //将temp插入找到的位置
            nums[j] = temp;
            System.out.println(Arrays.toString(nums));
        }
    }
    /**
     * 选择排序 从小到大
     * @param nums 随机生成待排序数组
     */
    public static void selectSort(int[] nums) {
        if(nums == null||nums.length<2){ return; }
        for (int i = 0; i < nums.length - 1; i++) {
            int minIndex=i;
            for (int j = i; j < nums.length; j++) {
                if(nums[j]<nums[minIndex]){
                    minIndex = j;
                }
            }
            int temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
//            System.out.println(i+":"+Arrays.toString(nums));
        }
    }
    /**
     * 冒泡排序 从小到大
     * @param nums 随机生成的数组
     */
    public static void bubbleSort(int[] nums) {
        if(nums == null||nums.length<2){ return; }
        int index = nums.length-1;
        for (int i = 0; i < index; i++) {
            int modCount = 0;
            for (int j = 0; j < index-i; j++) {
                if(nums[j]>nums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                    modCount++;
                }
            }
            if(modCount==0) { break; }
//            System.out.println(i+":" + Arrays.toString(nums));
        }
    }
}