我有一个面试，有以下问题：
在少于 O(n) 的时间内从排序的数组中找到唯一的数字。
Ex: 1 1 1 5 5 5 9 10 10 Output: 1 5 9 10
我给出了解决方案，但那是 O(n)。
编辑：排序后的数组大小约为 200 亿，唯一数约为 1000。
【问题讨论】：
3，就可以停止循环。
标签： java algorithm time-complexity
如果您的大小为n 的排序数组具有m 不同的元素，您可以使用O(mlogn)。
请注意，当m << n (eg m=2 and n=100) 时，这将有效
算法：
初始化：当前元素y = first element x[0]
第 1 步：对 y 在 x 中的最后一次出现进行二分搜索（可以在 O(log(n)) 时间完成。让它的索引为 i
第 2 步：y = x[i+1] 并转到第 1 步
编辑：在m = O(n) 的情况下，此算法将无法正常工作。为了缓解它，您可以与常规 O(n) 算法并行运行它。元算法由我的算法和并行运行的O(n) 算法组成。当这两种算法中的任何一种完成时，元算法就会停止。
【讨论】：
import java.util.*;
/**
* remove duplicate in a sorted array in average O(log(n)), worst O(n)
* @author XXX
*/
public class UniqueValue {
public static void main(String[] args) {
int[] test = {-1, -1, -1, -1, 0, 0, 0, 0,2,3,4,5,5,6,7,8};
UniqueValue u = new UniqueValue();
System.out.println(u.getUniqueValues(test, 0, test.length - 1));
}
// i must be start index, j must be end index
public List<Integer> getUniqueValues(int[] array, int i, int j) {
if (array == null || array.length == 0) {
return new ArrayList<Integer>();
}
List<Integer> result = new ArrayList<>();
if (array[i] == array[j]) {
result.add(array[i]);
} else {
int mid = (i + j) / 2;
result.addAll(getUniqueValues(array, i, mid));
// avoid duplicate divide
while (mid < j && array[mid] == array[++mid]);
if (array[(i + j) / 2] != array[mid]) {
result.addAll(getUniqueValues(array, mid, j));
}
}
return result;
}
}
【讨论】：
分而治之：
data[0]..data[data.length-1]）。 在平均情况下以 O(log(n)) 求解，而在最坏情况下（当每个元素不同时）仅在 O(n) 内求解。
Java 代码：
public static List<Integer> findUniqueNumbers(int[] data) {
List<Integer> result = new LinkedList<Integer>();
findUniqueNumbers(data, 0, data.length - 1, result, false);
return result;
}
private static void findUniqueNumbers(int[] data, int i1, int i2, List<Integer> result, boolean skipFirst) {
int a = data[i1];
int b = data[i2];
// homogenous sequence a...a
if (a == b) {
if (!skipFirst) {
result.add(a);
}
}
else {
//divide & conquer
int i3 = (i1 + i2) / 2;
findUniqueNumbers(data, i1, i3, result, skipFirst);
findUniqueNumbers(data, i3 + 1, i2, result, data[i3] == data[i3 + 1]);
}
}
【讨论】：
由于数据由整数组成，因此在任意两个值之间可以出现有限数量的唯一值。因此，首先查看数组中的第一个和最后一个值。如果a[length-1] - a[0] < length - 1，会有一些重复值。将a[0] 和a[length-1] 放入某个恒定访问时间的容器中，例如哈希集。如果这两个值相等，则您知道数组中只有一个唯一值，您就完成了。你知道数组是排序的。因此，如果这两个值不同，您现在可以查看中间元素。如果中间元素已经在值集中，您就知道可以跳过数组的整个左侧部分，只递归分析右侧部分。否则，递归分析左右部分。
根据数组中的数据，您将能够在不同数量的操作中获得所有唯一值的集合。如果所有值都相同，您将在恒定时间O(1) 中获得它们，因为您只需检查第一个和最后一个元素即可知道它。如果存在“相对较少”的唯一值，您的复杂性将接近O(log N)，因为在每个分区之后，您将“经常”能够丢弃至少一半的分析子阵列。如果这些值都是唯一的并且a[length-1] - a[0] = length - 1，您还可以在恒定时间内“定义”该集合，因为它们必须是从a[0] 到a[length-1] 的连续数字。但是，为了真正列出它们，您必须输出每个数字，并且有 N 个。
也许有人可以提供更正式的分析，但我的估计是，这个算法在唯一值的数量上大致是线性的，而不是数组的大小。这意味着，如果唯一值很少，即使对于一个巨大的数组，您也可以在很少的操作中获得它们（例如，如果只有一个唯一值，则在恒定时间内不管数组大小如何）。由于唯一值的数量不大于数组的大小，因此我声称这使得该算法“优于 O(N)”（或者，严格地说：“不比 O(N) 差，并且在许多情况下更好” )。
【讨论】：
我不认为它可以在少于 O(n) 的时间内完成。以数组包含 1 2 3 4 5 的情况为例：为了获得正确的输出，必须查看数组的每个元素，因此 O(n)。
【讨论】：