一题三解|最小可用ID

最小可用ID

描述
在非负数组(乱序)中找到最小的可分配的id(从1开始编号)，数据量1000000。
例如(3，2，1，5，8，6)中，最小可用ID为4。

解法1
将乱序数组排序之后，对数组中的数字进行位置确认。即第x个数字要在x - 1的索引上。复杂度O(nlgn)

private static int f(int[] arr) {
		Arrays.sort(arr);
		int res = arr[arr.length - 1] + 1;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] != i + 1) {
				res = i + 1;
				break;
			}
		}
		return res;
	}

解法2
借助辅助空间来进行位置确认。首先将未缺失的数字在辅助数组上的对应位置标记为1，缺失的默认标记为0。然后遍历辅助数组找出第一个标记为0的数字。

// O(n)
	private static int f2(int[] arr) {
		int[] helper = new int[arr.length + 1];
		// 1 2 3 * 5| 6
		// 0 1 1 1 0 1| 1
		// 将没有缺失的数字按顺序标记在辅助数组的位置上
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] <= helper.length - 1) {// 防止越界,一旦越界就说明前面有空缺的数字，所以就没必要标记越界的数字了
				helper[arr[i]] = 1;// 数字转下标并标记
			}
		}
		// 找出最小的缺失数字
		for (int i = 1; i < helper.length; i++) {
			if (helper[i] == 0) {
				return i;
			}
		}
		// 1至n都没有缺失
		return arr[arr.length - 1] + 1;
	}

解法3
解法3在保证效率的同时，没有借助辅助空间，是一个递归函数的设计。

1. 利用快排的partition算法对数组分区并找到数组中间位置的数字(midVal)(要知道partition返回的x索引代表着数组第x+1小的元素)
2. 若midVal = 中间位置的索引+1（例如50=49+1）说明mid左侧是紧凑的，是未缺失的。因此该去右侧寻找ID。（递归）
3. 若midVal > 中间位置索引 + 1则说明mid左侧是有数字缺失，是存在最小ID的。因此该去左侧寻找ID。
4. 递归出口，可以建立一个小规模的数组自己推演。

// 在[begin，end]中找到最小的可用ID
	private static int f3(int[] arr, int begin, int end) {
		// 递归终止条件自行推演出来
		if (begin > end) {
			return begin + 1;
		}
		int indexOfMid = (begin + end) / 2;
		int midVal = select(arr, begin, end, indexOfMid - begin + 1);// 分区并返回第indexOfMid+1小的元素,即返回了中间位置的数字
		int t = indexOfMid + 1;// 期望数字
		if (midVal == t) {// 左侧紧凑
			begin = indexOfMid + 1;
			return f3(arr, begin, end);
		} else {// midVal > t 左侧稀疏
			end = indexOfMid - 1;
			return f3(arr, begin, end);
		}
	}

	// 返回乱序数组中的第x小元素
	private static int select(int[] arr, int begin, int end, int x) {
		int indexOfPivot = partition(arr, begin, end);
		int th = indexOfPivot - begin + 1;// 主元是第几个元素
		if (x == th) {
			return arr[indexOfPivot];
		} else if (x > th) {// 去右侧寻找
			begin = indexOfPivot + 1;
			return select(arr, begin, end, x - th);
		} else {
			end = indexOfPivot - 1;
			return select(arr, begin, end, x);
		}
	}

	// 分区函数
	private static int partition(int[] arr, int begin, int end) {
		int pivot = arr[begin];
		int left = begin + 1;
		int right = end;
		while (left <= right) {
			while (left <= right && arr[left] <= pivot) {
				left++;
			}
			while (left <= right && arr[right] > pivot) {
				right--;
			}
			if (left < right) {
				swap(arr, left, right);
			}
		}
		swap(arr, begin, right);
		return right;
	}

	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}