1.荷兰国旗问题
给定一个数组arr，和一个数num，请把小于num的数放在数组的 左边，等于num的数放在数组的中间，大于num的数放在数组的右边。
要求额外空间复杂度O(1)，时间复杂度O(N)
public class Code_08_NetherlandsFlag {
public static int[] partition(int[] arr, int l, int r, int p) {
int less = l - 1;
int more = r + 1;
while (l < more) {
if (arr[l] < p) {
swap(arr, ++less, l++);
} else if (arr[l] > p) {
swap(arr, --more, l);
} else {
l++;
}
}
return new int[] {
less + 1, more - 1 };
}
// for test
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
// for test
public static int[] generateArray() {
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * 3);
}
return arr;
}
// 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();
}
public static void main(String[] args) {
int[] test = generateArray();
printArray(test);
int[] res = partition(test, 0, test.length - 1, 1);
printArray(test);
System.out.println(res[0]);
System.out.println(res[1]);
}
}
2.快速排序
2.1经典快排
如果明白了上面的荷兰国旗问题的话，快排就很容易理解了。
荷兰国旗问题是将指定的一个数字放在中间，两边分别是大于它和小于它的数字。我们将指定数字两侧的数字再进行如此操作，循环往复，直到全部有序，就ok了，这就是快速排序！！！
当然，也有可能有人会问，两侧随机的时候，怎么随机指定一个数字？很简单，我们默认每次都指定最后的一个元素即可。
java代码：
package basic_class_01;
import java.util.Arrays;
public class Code_04_QuickSort {
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) {
int[] p = partition(arr, l, r);
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;
}
// for test
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
// 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);
quickSort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {
succeed = false;
printArray(arr1);
printArray(arr2);
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
quickSort(arr);
printArray(arr);
}
}
2.2随机快排
随机快排是对快排的优化，效率更高！
经典快排划出来的左边区域和右边区域，很有可能是不平等的。这样可能每次只搞定一次数，在最差情况下，快排时间复杂为O(n2)，和数据状况有关系！
随机快排，就是在数组中，随机选择一个数字，然后用这个数和数组最后一个元素换位置，这样说，就不能说，轻易找到最差情况，当然也有可能。随机快排的复杂度是一个长期期望的复杂度O(N*logN)，额外控件复杂度O(logN)
代码上面来说，只是加上一行，随机数组中一个数和数组最后的元素的进行交换的代码
swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
3.堆排序
堆排本身就很重要了，但是更重要的是，堆这一个结构！！!
3.1堆
堆这结构其实就是一个完全二叉树。
二叉树我们都知道，就是一棵树下面有俩孩子，那什么是完全二叉树哪？
要么是一个满二叉树或者每一层是从左到右依次补齐的。
什么是满二叉树哪？就是最后一层都是叶节点，剩下的部分两个节点都全。
(注：叶节点就是下面没有节点)
二叉树其实我们可以用数组去表示
举个例子：
那这到底要怎么对应呢？一个下标为i，它的孩子是什么呢？
2i+1,就是他的左节点
2i+2,就是他的右节点
而一个i他的父节点是什么呢？
（i-1）/2,就是他父节点的小标
所以当你有一个数组，有上面的关系，你就可以脑补出一个完全二叉树。
换句话说，并不存在实际的完全二叉树，他就是数组结构，只是在数组结构中，定义了一个规则，我们可以在这个规则中，产生与之相对应的完全二叉树。
3.2大根堆和小根堆
堆就是完全二叉树，谈到堆，就有一个隐藏含义：到底是大根堆还是小根堆。那他俩都是啥含义呢？
先说大根堆，在一个完全二叉树中，任何一个子树的最大值，都是头部。
举个例子：
小根堆同理，任何一个子树的最小值，都是头部，就是小根堆。
问题来了，我给你一个数组，你怎么把它调成大根堆？
我们假设有一个数组，把它想象成一个完全二叉树。让它每一个节点的头部，和它的两个孩子做比较，如果大于等于。那就不用动，如果小于，那就让大的那个孩子和头部换位置，以此，循环往复。
java代码：
private static void a(int[] arr) {
if(arr==null||arr.length<2){
return;
}
//把数组变成大根堆
for (int i=0;i<arr.length;i++){
b(arr,i);
}
}
private static void b(int[] arr, int index) {
while (arr[index]>arr[(index-1)/2]){
s(arr,index,(index-1)/2);
index = (index-1)/2;
}
}
private static void s(int[] arr, int x, int y) {
int t = x;
x = y;
y = t;
}
那将一个数组转化为大根堆的事件复杂度为O(N)
那我们假设数组中有一个值发生变化了，变小了，怎么样调整才能让它继续还是大根堆？
那就找出他的两个孩子中的最大值，让他和他的两个孩子进行比较，如果他大，不用动，如果他小，就和他较大的儿子换位置，以此往复
public static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1;
while (left < size) {
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index;
if (largest == index) {
break;
}
swap(arr, largest, index);
index = largest;
left = index * 2 + 1;
}
}
3.3堆排序
第一步：让这个数组变成大根堆
第二步：把最后一个位置和第一个位置做交换
第三步：让堆的大小减一
第四步：在剩下的数组中，做上面改变一个数组的值的过程，就重新调整成大根堆
第五步：把堆顶和数组第二个位置交换
循环往复，减完为止。
package basic_class_01;
import java.util.Arrays;
public class Code_03_HeapSort {
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int size = arr.length;
swap(arr, 0, --size);
while (size > 0) {
heapify(arr, 0, size);
swap(arr, 0, --size);
}
}
public static void heapInsert(int[] arr, int index) {
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}
public static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1;
while (left < size) {
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index;
if (largest == index) {
break;
}
swap(arr, largest, index);
index = largest;
left = index * 2 + 1;
}
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
// for test
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
// 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);
heapSort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
heapSort(arr);
printArray(arr);
}
}