文章目录
- [1. 颜色分类（75）](#1. 颜色分类（75）)
- [2. 排序数组（912）](#2. 排序数组（912）)
- [3. 数组中的第K个最大元素（215）](#3. 数组中的第K个最大元素（215）)
- [4. 库存管理 III（LCR 159）](#4. 库存管理 III（LCR 159）)
1. 颜色分类（75）
题目描述：
算法原理：
颜色分类是比较经典的分治问题，我们通过left，right以及i来将数组分为四个部分，如下图。
如上图，0到left区间我们全是处理好的0数字，left+1到i-1是处理好的数字1，i到right-1是待处理的数字，right到n-1是处理好的数字2。
后面我们分情况分析，当i处理到数字0的时候，此时和left+1位置的元素交swap(nums,++left,i++)。当i处理到数字1时，因为left+1到i-1的区间就是包含数字1的区间，所以对于这种情况直接i++。当i处理到数字2时，交换right-1位置的值即swap(nums,i,--right)，此时i没有必要去加一，因为交换过来的元素还是未处理的元素，所以要继续处理交换过来的元素。
代码如下：
java
class Solution {
public void sortColors(int[] nums) {
int left = -1, right = nums.length;
int i = 0;
while (i < right) {
if (nums[i] == 0) {
swap(nums, ++left, i++);
} else if (nums[i] == 1) {
i++;
} else {
swap(nums, --right, i);
}
}
}
public void swap(int[] nums, int m, int n) {
int temp = nums[m];
nums[m] = nums[n];
nums[n] = temp;
}
}2. 排序数组（912）
题目描述：
算法原理：
使用分治多指针的思想去完成快速排序，思路和上题一样，只不过上一题是将数组分为三个不同数字的部分，这一题则是去选定一个key将数组分为大于key小于key以及等于key的三部分。至于key的选取，我们采用随机的方式。
代码如下：
java
class Solution {
public int[] sortArray(int[] nums) {
qsort(nums, 0, nums.length - 1);
return nums;
}
public void qsort(int[] arr, int l, int r) {
if (l >= r) {
return;
}
int i = l;
int key = arr[new Random().nextInt(r - l + 1) + l];
int left = l - 1, right = r + 1;
while (i < right) {
if (arr[i] < key) {
swap(arr, ++left, i++);
} else if (arr[i] == key) {
i++;
} else {
swap(arr, --right, i);
}
}
qsort(arr, l, left);
qsort(arr, right, r);
}
public void swap(int[] arr, int n1, int n2) {
int temp = arr[n1];
arr[n1] = arr[n2];
arr[n2] = temp;
}
}3. 数组中的第K个最大元素（215）
题目描述：
算法原理：
思想还是类似的，使用随机的key来将数组分为大于小于等于三部分，然后计算出大于部分的元素个数为c，等于部分的元素个数为b。当题目要求的k满足c>=k时就在大于区间里面找，当b+c>=k,那么就直接返回key的值即可，因为此时第k个元素肯定落在等于key的区间，该区间又全是key因此直接返回key即可，剩下的一种可能也是根据个数去找即可。
代码如下：
java
class Solution {
public int findKthLargest(int[] nums, int k) {
return quickSelect(nums, 0, nums.length - 1, k);
}
public int quickSelect(int[] arr, int l, int r, int k) {
if (l >= r) {
return arr[l];
}
int left = l - 1, right = r + 1, i = l;
int key = arr[new Random().nextInt(r - l + 1) + l];
while (i < right) {
if (arr[i] < key) {
swap(arr, ++left, i++);
} else if (key == arr[i]) {
i++;
} else {
swap(arr, --right, i);
}
}
int b = right - left - 1;
int c = r - right + 1;
if (c >= k) {
return quickSelect(arr, right, r, k);
} else if (b + c >= k) {
return key;
} else {
return quickSelect(arr, l, left, k - b - c);
}
}
public void swap(int[] arr, int n1, int n2) {
int temp = arr[n1];
arr[n1] = arr[n2];
arr[n2] = temp;
}
}4. 库存管理 III（LCR 159）
题目描述：
算法原理：
这一题其实有很多种方法，但是这里还是使用分治的思想去解决。观察题目得知实际上这就是一个让我们去求出一个数组中的前cnt个最小的值。
使用的思想和第三题类似，只不过这题在代码中不需要去返回值，而是只需要去排序，对于前k个最小值不可能出现的区间我们直接跳过，最终在主要的函数中对于排序好的数组直接取出最小的k个数构成数组返回。
代码如下：
java
class Solution {
public int[] inventoryManagement(int[] stock, int cnt) {
quickSort(stock, 0, stock.length - 1, cnt);
int[] ret = new int[cnt];
for (int i = 0; i < cnt; i++) {
ret[i] = stock[i];
}
return ret;
}
public void quickSort(int[] arr, int l, int r, int k) {
if (l >= r) {
return;
}
int i = l;
int left = l - 1;
int right = r + 1;
int key = arr[new Random().nextInt(r - l + 1) + l];
while (i < right) {
if (arr[i] < key) {
swap(arr, ++left, i++);
} else if (arr[i] == key) {
i++;
} else {
swap(arr, --right, i);
}
}
int a = left - l + 1;
int b = right - left - 1;
if (a >= k) {
quickSort(arr, l, left, k);
} else if (a + b >= k) {
return;
} else {
quickSort(arr, right, r, k - a - b);
}
}
public void swap(int[] arr, int n1, int n2) {
int t = arr[n1];
arr[n1] = arr[n2];
arr[n2] = t;
}
}