荷兰国旗问题的递归调用就是快速排序
代码如下
public class Code17_PartitionAndQuickSort {
/**
* 荷兰国旗 和 快速排序
*
* 荷兰国旗问题
* 给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。
* 要求额外空间复杂度O(1）,时间复杂度 O(N）
*
*
* <= X > X
*
* */
//交换函数
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
/**
* 给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，
* 大于num的数放在数组的右边。要求额外空间复杂度O(1）,时间复杂度 O(N）
* 从左到右，当遇到小于a的数 ，<=区向右进1
* 当遇到大于a的数 ，跳过
* 之后再遇到小于等于a的数 就当前数和小于等于区下一个数交换 小于等于区向右扩一
*
* */
//划分
public static int partition(int[] arr, int L, int R) {
if (L > R) {
return -1;
}
if (L == R) {
return L;
}
//定义小于区右边的边界
int lessEqual = L - 1;
//从左边开始
int index = L;
while (index < R) {
//以右边界为界限，来进行交换
if (arr[index] <= arr[R]) {
swap(arr, index, ++lessEqual);
}
index++;
}
//将最右边的X和小于等于下一个交换 将X归入进去
swap(arr, ++lessEqual, R);
return lessEqual;
}
/**
*
* 1 当前数<目标 当前数和 <区的下一个交换 <区 向右扩 当前数跳下一个
* 2 当前数=目标 当前数直接跳下一个
* 3 当前数>目标 当前数和 >区前一个交换 <区左扩 当前数不变
*
* arr[R]做划分 当成X
* */
//荷兰国旗 问题
//给定一个数组arr,和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的中间，
//大于num的数放在数组的右边。要求额外空间复杂度O(1)，时间复杂度O(N)
// arr[L...R] 玩荷兰国旗问题的划分，把数组的最右边的数作为X 以arr[R]做划分
//返回值 是等于区域的数组下标的范围
public static int[] netherlandsFlag(int[] arr, int L, int R) {
if (L > R) { // L...R L>R
return new int[] { -1, -1 };
}
if (L == R) {
return new int[] { L, R };
}
//定义小于等于区
int less = L - 1; // < 区 右边界
//定义大于等于区
int more = R; // > 区 左边界 R位置的数直接放在大于区域 在后面在换回来
int index = L;
//三种情况进行讨论
while (index < more) { // 当前位置，不能和 >区的左边界撞上
//当相等的时候 当前数直接跳下一个
if (arr[index] == arr[R]) {
index++;
} else if (arr[index] < arr[R]) {
//小于目标数
//当前值和小于区的下一位交换
// swap(arr, less + 1, index);
//小于区向右扩
// less++;
// index++;
//等价于上面三行代码
swap(arr, index++, ++less);
} else { // >
//当前值和大于区的前一位交换 大于区向左扩增
swap(arr, index, --more);
}
}
//最后处理最右边的这个数
//将X 和大于区域的第一个数交换 将最右边的归入等于区域
swap(arr, more, R); // <[R] =[R] >[R]
return new int[] { less + 1, more };
}
//快排 就是上面的一个递归过程
public static void quickSort1(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
process1(arr, 0, arr.length - 1);
}
public static void process1(int[] arr, int L, int R) {
if (L >= R) {
return;
}
// L..R partition arr[R] [ <=arr[R] arr[R] >arr[R] ]
//
int M = partition(arr, L, R);
process1(arr, L, M - 1);
process1(arr, M + 1, R);
}
public static void quickSort2(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
process2(arr, 0, arr.length - 1);
}
// arr[L...R] 排有序，快排2.0方式 搞定一批数
public static void process2(int[] arr, int L, int R) {
if (L >= R) {
return;
}
// [ equalArea[0] , equalArea[0]]
//能最先找到一组等于X的一组数 等于区域找到
//之后还是左右，各找新的划分值 再次递归确定
//这个数组是等于区域的数组的左右区域下标
int[] equalArea = netherlandsFlag(arr, L, R);
//小于区域 再拍戏
process2(arr, L, equalArea[0] - 1);
//大于区域 再排序
process2(arr, equalArea[1] + 1, R);
}
public static void quickSort3(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
process3(arr, 0, arr.length - 1);
}
public static void process3(int[] arr, int L, int R) {
if (L >= R) {
return;
}
//随机快排
//随机选择一个数来做划分值
//划分值定的越准 时间复杂度就是贴近(O(N*logN))
//长期的期望 数学家证明过 这个概率
swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
int[] equalArea = netherlandsFlag(arr, L, R);
process3(arr, L, equalArea[0] - 1);
process3(arr, equalArea[1] + 1, R);
}
//对数器
// for test
public static int[] generateRandomArray(int maxSize, int maxValue) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
}
return arr;
}
// for test
public static int[] copyArray(int[] arr) {
if (arr == null) {
return null;
}
int[] res = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
res[i] = arr[i];
}
return res;
}
// for test
public static boolean isEqual(int[] arr1, int[] arr2) {
if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
return false;
}
if (arr1 == null && arr2 == null) {
return true;
}
if (arr1.length != arr2.length) {
return false;
}
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
// for test
public static void printArray(int[] arr) {
if (arr == null) {
return;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
// for test
public static void main(String[] args) {
int testTime = 500000;
int maxSize = 100;
int maxValue = 100;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr1 = generateRandomArray(maxSize, maxValue);
int[] arr2 = copyArray(arr1);
int[] arr3 = copyArray(arr1);
quickSort1(arr1);
quickSort2(arr2);
quickSort3(arr3);
if (!isEqual(arr1, arr2) || !isEqual(arr2, arr3)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Oops!");
}
}
