指定最后一个元素是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