传统必会算法--快速排序

指定最后一个元素是privot [遍历前面的与他比较]，
counter表示小于privot的元素的个数，如果当前 i 的值小于privot则 交换counter位置与 i 位置的元素[通过这样遍历完毕则前counter全都小于privot]，并且counter++，
然后只需要最后一轮交换privot与counter的元素

• 第一轮：counter=0，i=0 的位置交换[默认不交换], counter++
• 第二轮：counter=1[当前有一个比3小了]，i=1的位置比较发现标杆大于当前位置，counter不变，也即不需要交换。
• 第三轮：counter=1，i=2，发现标杆大于当前位置，需要交换当前位置与counter，并且counter++ [3,1,5,2,4]
• 第四轮：counter=2，i=3，发现标杆大于当前位置，需要交换当前位置与counter，并且counter++ [3,1,2,5,4]
• 循环终止：i=end了，循环结束，此时counter=3，意思是总共有三个小于它的值，循环外面把counter与标杆的值交换。

注意递归，需要先写出口。
注意python、Java里面数组都是引用

public class QuickSort {

    public static void sort(int[] input, int begin, int end) {
        if (begin >= end) {
            return;
        }
        int privot = partition(input, begin, end);
        sort(input, begin, privot-1);
        sort(input, privot+1, end);
    }

    private static int partition(int[] input, int begin, int end) {
        int privot = end, counter = begin;
        for (int i = begin; i<end; i++) {
            if (input[i] < input[privot]) {
                int tmp = input[counter];
                input[counter] = input[i];
                input[i] = tmp;
                counter++;
            }
        }
        int tmp = input[counter];
        input[counter] = input[privot];
        input[privot] = tmp;
        return counter;
    }

    public static void main(String[] args) {
        int[] input = new int[]{
                3, 5, 4, 1, 2
        };
        sort(input, 0, input.length-1);
        List<Integer> ints = Arrays.stream(input).boxed().collect(Collectors.toList());
        System.out.println(ints);
    }
}

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        self.quickSort(nums, 0, len(nums)-1)
        return nums

    def quickSort(self, nums, l, r):
        if l > r:
            return nums
        m = self.partation(nums, l, r)
        self.quickSort(nums, l, m - 1)
        self.quickSort(nums, m + 1, r)

    def partation(self, nums, l, r):
        privot, counter, i = r, l, l
        while i < r:
            if nums[i] < nums[privot]:
                nums[counter], nums[i] = nums[i], nums[counter]
                counter += 1
            i += 1
        nums[privot], nums[counter] = nums[counter], nums[privot]
        return counter