迭代式快排与递归式快排

迭代式快排

在迭代解决方案中，我们将使用堆栈。下面是在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)之间，调度好。