Java实现各种排序

重新温习下排序算法，主要有：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序。

/**
 * @date 2020-08-28 09:41
 */
public class SortTest {

    //冒泡排序
    private void bubbleSort(int[] nums) {
        //外部循环，趟数
        for (int i = 0; i < nums.length; i++) {
            //内部循环，获取一个最大值，向下沉
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    //选择排序：将i前面的数据看成一个排序好的队列，i后面的数据看成一个无序的队列。每次只需要找出无序数中的最小值，做替换即可。
    private void selectSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            int minIndex = i;
            int min = nums[i];
            for (int j = i + 1; j < nums.length; j++) {
                if (min > nums[j]) {
                    min = nums[j];
                    minIndex = j;
                }
            }
            int temp = nums[i];
            nums[i] = min;
            nums[minIndex] = temp;
        }
    }

    //错误的写法
    private void selectSortWrong(int[] nums) {
        //外部循环是(假设)有序的
        for (int i = 0; i < nums.length; i++) {
            int minIndex = i;
            //内部循环中寻找最小的数
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] > nums[j]) {//用nums[i]比较，是不正确的
                    minIndex = j;//这样内部循环完，只会记录比nums[i]小的下标，并没有找到最小值。因此需要有一个变量来记录当前找到的最小值
                }
            }
            //将真正的最小值和开始值进行交换
            int temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
        }
    }

    //插入排序：默认将第一个数据看成有序列表，后面无序的列表循环每一个数，如果比前面的数据小则插入，否则退出
    private void insertSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            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;
                }
            }
        }
    }

    //希尔排序：先分组，再对分好的组进行插入排序
    private void shellSort(int[] nums) {
        //进行分组，最开始的增量为数组长度的一半
        for (int gap = nums.length; gap > 0; gap /= 2) {
            shell(nums, gap);
        }
    }

    private void shell(int[] nums, int gap) {
        //对各个分组进行插入排序
        for (int i = gap; i < nums.length; i++) {
            //将nums[i]插入到所在分组的正确位置上
            //nums[i]所在的分组为：nums[i-2*gap]、nums[i-gap]、nums[i]、nums[i+gap]、nums[i+2*gap]...
            for (int j = i; j > 0 && j - gap >= 0; j -= gap) {

                if (nums[j] < nums[j - gap]) {
                    int temp = nums[j];
                    nums[j] = nums[j - gap];
                    nums[j - gap] = temp;
                } else {
                    break;
                }

            }

        }
    }

    //快速排序
    private void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int point = partition(nums, low, high);
            quickSort(nums, low, point - 1);
            quickSort(nums, point + 1, high);
        }
    }

    private int partition(int[] nums, int low, int high) {
        int tmp = nums[low];//tmp存放基准数
        while (low < high) {
            while (low < high && nums[high] >= tmp) {
                high--;
            }
            nums[low] = nums[high];//把比基准数小的放在左边
            while (low < high && nums[low] <= tmp) {
                low++;
            }
            nums[high] = nums[low];//把比基准数大的放在右边
        }
        nums[low] = tmp;
        return low;//返回当前基准值
    }

    //归并排序
    private void mergeSort(int[] nums, int[] tmp, int startIndex, int endIndex) {
        if (startIndex < endIndex) {
            int midIndex = (startIndex + endIndex) / 2;
            mergeSort(nums, tmp, startIndex, midIndex);
            mergeSort(nums, tmp, midIndex + 1, endIndex);
            merge(nums, tmp, startIndex, midIndex, endIndex);
        }
    }

    private void merge(int[] nums, int[] tmp, int startIndex, int midIndex, int endIndex) {
        int i = startIndex;//当前小组二分后第一个小组首号下标
        int j = midIndex + 1;//当前小组二分后第二个小组首号下标
        int k = startIndex;//记录临时数组的下标

        while (i != midIndex + 1 && j != endIndex + 1) {
            if (nums[i] > nums[j]) {
                tmp[k++] = nums[j++];
            } else {
                tmp[k++] = nums[i++];
            }
        }

        //左边小组剩下的所有数字
        while (i != midIndex + 1) {
            tmp[k++] = nums[i++];
        }
        //右边小组剩下的所有数字
        while (j != endIndex + 1) {
            tmp[k++] = nums[j++];
        }

        //临时数组中排好序的值拷到原数组中
        for (int index = startIndex; index <= endIndex; index++) {
            nums[index] = tmp[index];
        }
    }

    public static void main(String[] args) {
        SortTest test = new SortTest();
        int[] nums = {12, 3, 23, 11, 0, 2, 9};
//        System.out.print("冒泡排序算法：");
//        test.bubbleSort(nums);
//
//        System.out.print("选择排序算法：");
//        test.selectSort(nums);

//        System.out.print("插入排序算法：");
//        test.insertSort(nums);

//        System.out.print("希尔排序算法：");
//        test.shellSort(nums);

//        System.out.print("快速排序算法：");
//        test.quickSort(nums, 0, nums.length - 1);

        System.out.print("归并排序算法：");
        int[] tmp = new int[nums.length];
        test.mergeSort(nums, tmp, 0, nums.length - 1);

        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }

    /**
     * 插入排序：直接插入排序   希尔排序
     * 交换排序：冒泡排序      快速排序
     * 选择排序：直接选择排序   归并排序
     *
     * 时间复杂度为O(n^2):直接插入排序、冒泡排序、直接选择排序
     * 时间复杂度为O(nlog2n):希尔排序、快速排序、归并排序
     *
     * 数据量大选希尔排序、快速排序、归并排序。在基本有序的情况下，选插入排序或者冒泡排序
     */
}

看动图理解排序思想，可参考博文：https://www.cnblogs.com/ll409546297/p/10956960.html