快速排序

package com.heu.wsq.basic.sort_algorithm;

import com.sun.xml.internal.bind.v2.model.annotation.Quick;

/**
 * 快速排序
 * @author wsq
 * @date 2021/4/17
 * 快速排序的思想：通过一趟排序将记录分隔为独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分
 * 记录继续进行排序，以达到整个序列有序。
 *
 * 快速排序使用分治法把一个串（list）分为两个子串（sub-lists）。算法具体描述如下：
 * 1. 从数列中挑出一个元素，称为基准
 * 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
 * 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
 * 3. 递归（recursive）把小于基准值元素的子数列和大于基准值的子数列排序。
 */
public class QuickSort {
    public void sort(int[] nums){
        int n = nums.length;
        sort(nums, 0, n - 1);
    }

    private void sort(int[] nums, int start, int end) {
        if(start >= end){
            return;
        }
        int j = partition(nums, start, end);
        sort(nums, start, j - 1);
        sort(nums, j + 1, end);
    }

    private int partition(int[] nums, int start, int end) {
        int i = start + 1;
        int j = end;
        int v = nums[start];
        while(true){
            // 从左侧寻找大于v的值对应的索引
            while(less(nums[i], v) || nums[i] == v) {
                if (i == end) {
                    break;
                }
                i++;
            }
            // 从右侧寻找小于v的值对应的索引
            while(less(v, nums[j]) || v == nums[j]) {
                if (j == start){
                    break;
                }
                j--;
            }
            if(i >= j){
                break;
            }
            swap(nums, i, j);
        }
        // 将哨兵位放在j对应的位置
        swap(nums, start, j);
        return j;
    }

    private boolean less(int num1, int num2) {
        return num1 < num2;
    }

    private void swap(int[] nums, int start, int j) {
        int tmp = nums[start];
        nums[start] = nums[j];
        nums[j] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = {2, 7, 2, 4, 1, 2, 8, 5};
        QuickSort quickSort = new QuickSort();
        quickSort.sort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}