LeetCode210408快速排序和冒泡、选择、插入、希尔排序

快速排序

	public static void quickSort(int[] nums,int start,int end){

        if (start > end) {
            return;
        }

        int index = partition1(nums,start, end);

        quickSort(nums,index+1,end);
        quickSort(nums,start,index-1);

    }

    private static int partition1(int[] nums, int start, int end) {

        int left = start;
        int right = end;

        int pivot = nums[start]; // 基准数

        while (left < right) {

            while (left < right && nums[right] >= pivot) { // pivot右边的数必须比pivot大，否则即找到比pivot小的最新数
                right--; // // 从最右边向左寻找比pivot大的数，每符合一步右指针左移。当找到比pivot小的数，右指针暂时停止向左移动
            }
            nums[left] = nums[right]; // 将在右边找到的比pivot小的数 替换到左边

            while (left < right && nums[left] <= pivot) { // pivot左边的数必须比pivot小
                left++;
            }
            nums[right] = nums[left]; // 对称

        }
        nums[left] = pivot; // 此时left++后，新的left值赋值给了right,此时旧的left值应该被剩余的pivot所赋。
        return left;

    }

冒泡

	public static void bubbleSort(int[] nums) {

        int n = nums.length;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - 1 - i; j++) { // 每一轮固定一个最大值，少比较一次
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                }
            }
        }
    }

选择

	public static void selectSort(int[] nums){

        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int currMinIndex = i; //
            for (int j = i; j < n-1; j++) { // 防止j+1数组角标越界
                if (nums[currMinIndex]>nums[j+1]){
                    currMinIndex = j+1;
                }
            }
            swap(nums,currMinIndex,i);
        }
    }

插入

	public static void insertSort(int[] nums) {

        int n = nums.length;

        for (int i = 0; i < n - 1; i++) {

            int currNum = nums[i + 1]; // 初始当前数为第二个数
            int prev = i;

            while (prev >= 0 && currNum < nums[prev]) { // 如果当前数大于前一个数，则停止寻找位置
                nums[prev + 1] = nums[prev];
                prev--;
            }
            nums[prev + 1] = currNum;
        }
    }

希尔

	public static void shellSort(int[] nums) {

        int n = nums.length;
        int gap = n / 2;

        while (gap > 0) {
            for (int i = gap; i < n; i++) {
                int temp = nums[i];
                int prev = i-gap; // 该组数的前值
                while (prev>=0&&nums[prev] > temp) { // 当前面值比后值大才做插入替换操作
                    nums[prev+gap] = nums[prev];
                    prev -= gap;
                }
                nums[prev+gap] = temp;
            }
            gap /= 2;
        }
    }