Binary Search on Unsorted Array - 1point3acres

https://docs.google.com/document/d/1qxA2wps0IhVRWULulQ55W4SGPMu2AE5MkBB37h8Dr58/

随机数组中用二分法找不到的元素

第四题，一个印度小哥，给定一个没有排序的随机数组，使用二分法找数组里的各个元素，返回有多少元素是用二分法永远找不到的。要求算法复杂度为O(n), 楼主不会。印度小哥让楼主用例子试一试，看看能不能找到什么规律。楼主试了试，没找到规律…………最后给出了nlog（n）的解法，估计最后挂在这了。

思路：

可以用类似于判断树是否为BST的思路：维护一个“值域”R=(lo, hi)（即在当前搜索下标范围[i, j]内，只有在R范围内的数才有可能被二分法找到）。求得当前搜索范围[i, j]的中点mid。如果A[mid]在当前的R中，那A[mid]就一定能被找到。然后分别递归mid的左右两侧[i, mid-1]和[mid+1, j]。递归左侧时，允许的值域是(lo, A[mid])；同理右侧的值域是(A[mid], hi)。如果任何时刻发现值域R已经不包含任何整数，那就表示[i, j]这个下标范围内没有任何能找到的数字。

code

provider: null

   private int find(int[] nums) {

    // do some sanity check operations

    return dfsUtil(nums, 0, nums.length - 1, Integer.MIN_VALUE, Integer.MAX_VALUE);

   }

   private int dfsUtil(int[] nums, int left, int right, int lower, int upper) {

// base case: there should be no elements between (lower, upper) or (left,right)

    if(lower >= upper) return right - left + 1;

    if(left > right) return 0;

   

    int mid = left + (right - left) / 2;

    int l = dfsUtil(nums, left, mid-1, lower, nums[mid]);

    int r = dfsUtil(nums, mid+1, right, nums[mid], upper);

    if(nums[mid] > lower && nums[mid] < upper) {

    return l + r;

    } else {

    return l + r + 1;

    }

   }

需要和面试官clarify是否包含重复值，如果包括，情况会更复杂一点。首先需要定义二分法是找左边界还是右边界，其次，不同位置同样的数是否当做同样的值。提供一个python版本代码。

def bs_in_unsorted_arr(unsorted):

   from collections import defaultdict

   lo, hi = -1 << 32,1 << 32

   left, right = 0, len(unsorted)

   found = defaultdict(bool)

   def bs(left, right, lo, hi):

       if left >= right:

           return

       if lo >= hi:

           return

       mid = (left + right) >> 1

       if lo <= unsorted[mid] < hi:

           found[unsorted[mid]] = True

       bs(left, mid, lo, min(unsorted[mid], hi))

       bs(mid + 1, right, max(unsorted[mid], lo), hi)

   bs(left, right, lo, hi)

   return found

无序数组二分搜索：找不到的数
假设给你一个有序数组，，那么如果二分搜索其中的每个数，必定都能找到。
如果给你同样的数组，但是却是打乱的，然后使用同样的二分搜索来搜索其中的每个数，会有些数找不到。
请你用 O(N)，返回哪些数找不到。

把这个无序数组直接用binarySearch 来搜索 [ 2, 7, 9, 10, 1 ]

l=0, h=4, m=2, 找9一次就可以找到。
找2，m=2 是9，所以在左边。则l=0, h=1, m=0, 可以找到
找7，m=2 是9，所以在左边。则l=0, h=1, m=0, 然后 l=1, h=1, m=1 可以找到
找10，m=2 是9，所以在右边。则l=3,h=4,m=3,能找到
找1，m=2 是9，所以在左边。则l=0,h=1,m=0 找不到。

所以对于这个题目，找不到的数是【1】。

如果知道中位数，则左半部＞中位数和右半部＜中位数的数会找不到。

那么如何在O(n)时间内找到中位数，可以用两个堆来找，或者平衡二叉树也可以。

再加一个例子：

Given nums: [22, 92, 25, 16, 29, 15, 49, 22, 38, 61]

Can't find: [16, 49, 25, 92, 15]

对于任意数组中的元素，如果用标准的二分法搜索搜索不到，就是最后答案的一员。当然下面的是测试代码，达不到楼顶要求的O(N)了。

for (int j : nums)

  if (Arrays.binarySearch(nums, j) < 0)

    System.out.println("Can't find " + j);

用堆或者Balanced BST的时间复杂度就不是O(N)了，找中位数果断用Quick Select啊

https://www.1point3acres.com/bbs/forum.php?mod=viewthread&tid=419382&page=2#pid3872585

然后考虑一个样例数组，比如
[4, 3, 5, 7, 6, 8, 2, 9, 1]

假设我们需要寻找8，那么输出是这样的：

1. Looking at position 4, value = 6
2. Now decide whether left [0, 3] or right [5, 8]
3. Go to right side!
4. Looking at position 6, value = 2
5. Now decide whether left [5, 5] or right [7, 8]. From 1point 3acres bbs
6. Go to right side!
7. Looking at position 7, value = 9
8. Now decide whether left [7, 6] or right [8, 8]
9. Go to left side!
10. Not found

也就是找不到8 —— 问题出在第二步position = 6的值为2，所以我们将左边的区间[5, 5]排除了。
. From 1point 3acres bbs
那么进入区间[5, 5]的条件是什么？—— 条件是查找值要大于第一步position = 4的值（也就是6）从而向右走，并小于第二步position = 6的值（也就是2）从而向左走，也就是查找值要大于6并小于2 —— 当然这个条件不可能被满足，所以不仅是7，position = 5的位置设成任何值都是不可能被找到的。

所以总体思路就是维护一个“查找值需要大于X并小于Y才能到达这个区间“的记录，并在递归的每一层更新X和Y

1. void CheckHidden(const std::vector<int> &data,
2.                  std::vector<bool> &hidden,
3.                  const int lo, const int hi,
4.                  const int min_bound, const int max_bound) {
5.   if (lo > hi) {
6.     return;. From 1point 3acres bbs
7.   }
8. 
   
9.   const int mid = (lo + hi) / 2;
10.   const int value = data[mid];
11. 
    
12.   // 打印更新边界的过程
13.   std::cout << "data[" << mid << "] = " << data[mid] << ", bound = "
14.             << "[" << min_bound << ", " << max_bound << "]]\n";
15. 
    
16.   // hidden记录每个位置的值是否能被查找到
17.   hidden[mid] = (value <= min_bound || value >= max_bound);
18. 
    
19.   CheckHidden(data, hidden, lo, mid-1, min_bound, std::min(value, max_bound));
20.   CheckHidden(data, hidden, mid+1, hi, std::max(min_bound, value), max_bound);
21. }
22. 
    
23. // Wrapper
24. void CheckHidden(const std::vector<int> &data, std::vector<bool> &hidden) {
25.   // 初始边界是负无穷到正无穷. From 1point 3acres bbs
26.   CheckHidden(data, hidden, 0, data.size() - 1,
27.               std::numeric_limits<int>::min(),
28.               std::numeric_limits<int>::max());
29. }