给定一个整数数组 A，对于每个整数 A[i]，我们可以选择 x = -K 或是 x = K，并将 x 加到 A[i] 中。

在此过程之后，我们得到一些数组 B。

返回 B 的最大值和 B 的最小值之间可能存在的最小差值。
示例 1：

输入：A = [1], K = 0
输出：0
解释：B = [1]
示例 2：

输入：A = [0,10], K = 2
输出：6
解释：B = [2,8]
示例 3：

输入：A = [1,3,6], K = 3
输出：3
解释：B = [4,6,3]

提示：

1 <= A.length <= 10000
0 <= A[i] <= 10000
0 <= K <= 10000

思路：
先排序，然后对于每一个A[i] 和 A[i + 1] 比较 min+K、A[i]+K、max-K、A[i+1]-K之间的大小即可

class Solution {
private:
	int randomInRange(int start, int end)
	{
		if (start == end)
			return start;

		srand((unsigned)time(NULL));
		if (start > end)
			return rand() % (start - end + 1) + end;
		else
			return rand() % (end - start + 1) + start;
	}
	int partition(vector<int> &nums, int start, int end)
	{
		if (start==end)
			return start;

		int index = randomInRange(start, end);
		swap(nums[index], nums[end]);
		int small = start - 1;
		for (int i = start; i < end; ++i)
		{
			if (nums[i] < nums[end])
			{
				small++;
				if (small != i)
					swap(nums[small], nums[i]);
			}
		}
		small++;
		swap(nums[end], nums[small]);
		return small;
	}

public:
	void quickSort(vector<int> &nums, int start, int end)
	{
		if (start == end)
			return;

		int index = partition(nums, start, end);
		if (index > start)
			quickSort(nums, start, index - 1);
		if (index < end)
			quickSort(nums, index + 1, end);
	}
	int smallestRangeII(vector<int>& A, int K)
	{
		if (A.size() == 1)
			return 0;
		
		quickSort(A, 0, A.size() - 1);
		int n = A.size() - 1;
		int res = A[n] - A[0];
		for (int i = 0; i < n; ++i)
		{
			int imax = A[i] + K> A[n] - K ? A[i] + K : A[n] - K;
			int imin = A[i + 1] - K < A[0] + K ? A[i + 1] - K : A[0] + K;
			res = min(res, imax - imin);
		}
		return res;
	}
};