迭代式快排
在迭代解决方案中,我们将使用堆栈。下面是在Java中实现迭代快速排序的步骤:
1.将范围(0…n)推入堆栈
2.使用数据透视表对给定数组进行分区
3.弹出顶部元素。
4.如果范围有多个元素,将分区(索引范围)推入堆栈
5.执行上述3个步骤,直到堆栈为空
public static void iterativeQsort(int numbers) {
Stack stack = new Stack();
stack.push(0);
stack.push(numbers.length);
while (!stack.isEmpty()) {
int end = stack.pop();
int start = stack.pop();
if (end - start < 2) {
continue;
}
int p = start + ((end - start) / 2);
p = partition(numbers, p, start, end);
stack.push(p + 1);
stack.push(end);
stack.push(start);
stack.push(p);
}
}
private static int partition(int input, int position, int start, int end) {
int l = start;
int h = end - 2;
int piv = input[position];
swap(input, position, end - 1);
while (l < h) {
if (input[l] < piv) {
l++;
} else if (input[h] >= piv) {
h--;
} else {
swap(input, l, h);
}
}
int idx = h;
if (input[h] < piv) {
idx++;
}
swap(input, end - 1, idx);
return idx;
}
private static void swap(int arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
此代码借鉴于https://www.jdon.com/51841
递归式快排
通过随机一个数,放在最后一个位置,通过此方法将好情况和坏情况的概率都为1/N,防止极端坏情况影响算法效率。
```java
public static void quickSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
quickSort(arr, 0, arr.length - 1);
}
public static void quickSort(int[] arr, int l, int r) {
if (l < r) {
swap(arr, l + (int) (Math.random() * (r - l + 1)), r);//随机选择
int[] p = partition(arr, l, r);//小于左边,大于右边,等于是p
quickSort(arr, l, p[0] - 1);
quickSort(arr, p[1] + 1, r);
}
}
// 荷兰国旗问题,分三块
public static int[] partition(int[] arr, int l, int r) {
int less = l - 1;
int more = r;
while (l < more) {
if (arr[l] < arr[r]) {
swap(arr, ++less, l++);
} else if (arr[l] > arr[r]) {
swap(arr, --more, l);
} else {
l++;
}
}
swap(arr, more, r);
return new int[] { less + 1, more };
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
其时间复杂度不稳定,在O(NlogN)~O(logN)之间,调度好。