search and sort

1. Rotated Sorted Array

这种题目如何在面试的时候自测？ 首先考虑长度为0， 1， 2的情况，code可不可通过。top level地讲就是：想一想你的code的base case是什么情况，也就是递归时top-down的down的case是不是边界严谨和清楚。

1.1 Search in Rotated Sorted Array

思路：l, r分别代表左边界右边界，也就是target所处的所有可能的位置的边界。哪一个loop都是这样的！我们每个loop只要缩小target可能出现的位置的范围就可以了。如果每次缩小一半，就是O(logN)的复杂度。

注意: 

• 在缩小范围的时候采用的方法并不是像常规的binary-search看target和A[mid]的关系了，而是看左右两边，哪边是sorted的，从而尽量多得缩减问题规模。
• 在看哪边sorted的时候，不要把A[l] 和 A[mid-1]比，因为mid-1可能越界！！和A[mid]比能取得相同的效果。注意是<= 而非 < !!为什么？？
• 为什么 后面为l, r赋值的时候不用考虑越界？ 因为首先 初始化的时候是没有越界的，在loop中，l<r时，mid肯定取到[l, r) 区间，肯定不会越界；l=r时，mid = l, 不论r取mid-1还是l取mid+1都会导致l>r，退出loop。
• 做到bug free很有难度

class Solution {
public:
    int search(int A[], int n, int target) {
        int l = 0, r = n-1;
        while(l <= r) {
            int mid = l + (r - l)/2;  //注意 l + r 有可能越界
            if (A[mid] == target) return mid;
            if (A[l] <= A[mid]) {  //左面没有rotated， 注意不要把A[l]和A[mid-1]比 因为mid-1可能越界
                if (A[l] <= target && target < A[mid]) r = mid - 1;
                else l = mid + 1;
            }
            else {  //右面没有rotated
                if (A[mid] < target && target <= A[r]) l = mid + 1;
                else r = mid - 1;
            }
        }
        return -1;
            
    }
};

注意，刚标红的问题，当A[l] = A[mid] 时，其实是l = mid的时候，头一次进入这个状况的时候是还剩两个元素的时候，所以while还可以这么写：

<span style="white-space:pre">	</span>while(l <= r) {
            int mid = l + (r - l)/2;
            if (A[mid] == target) return mid;
            if (A[l] < A[mid]) {  //左面没有rotated
                if (A[l] <= target && target < A[mid]) r = mid - 1;
                else l = mid + 1;
            }
            else if (A[mid] < A[r]) {  //右面没有rotated
                if (A[mid] < target && target <= A[r]) l = mid + 1;
                else r = mid - 1;
            }
            else if (mid == l) {  //下一个可能的范围就只能是[r,r]即r这个位置
                if (A[r] == target) return r;
                return -1;
            }
        }

1.2   Search in Rotated Sorted Array II

这一题目和上题相比加了元素可能有重复 这样的条件。如果像上题那么写while的话（即判断 A[l] <= A[mid] ?） 是不可以的，case: [1,3,1,1,1], [1,1,1,3,1], 想找3， 那么当A[0] = A[2]时, 你不知道3在左在右，因此不能成倍缩减问题规模，问题的复杂度上升为O(N)。

class Solution {
public:
    bool search(int A[], int n, int target) {
        return searchHelper(A, 0, n-1, target);
    }
    bool searchHelper(int A[], int l, int r, int target) {
        if (l > r) return false;
        int mid = l + (r - l) / 2;
        if (target == A[mid]) return true;
        if (A[l] == A[mid] && A[mid] == A[r])  //pay attention to the order of those "if"s
            return searchHelper(A, l, mid-1, target) || searchHelper(A, mid+1, r, target);  //两边都要看了
        if (A[l] <= A[mid]) {  //left is not rotated
            if (target >= A[l] && target < A[mid]) return searchHelper(A, l, mid-1, target);
            else return searchHelper(A, mid+1, r, target);
        }
        else {  //right is not rotated
            if (target > A[mid] && target <= A[r]) return searchHelper(A, mid+1, r, target);
            else return searchHelper(A, l, mid-1, target);
        }
    }
};

1.3 Find Minimum in Rotated Sorted Array

同样是利用l, r来代表可能的范围, base case在 如果可能范围内的num[l] < num[r] 那么答案就找到了，还有是长度为1， 2的时候，当然程序开始的时候要判断num长度是不是为0.

class Solution {
public:
    int findMin(vector<int> &num) {
        if (num.size() == 0)
            return INT_MIN;
        
        int l = 0, r = num.size()-1;
        while(l<=r) {
            if (num[l] < num[r]) return num[l];  //边界条件
            int mid = l + (r - l) / 2;
            if (num[l] < num[mid])  //mid在左半边
                l = mid;
            else if (num[mid] < num[r])  //mid在右半边，和if (num[l] > num[mid])一个效果
                r = mid;
            else 
                return min(num[l], num[r]);
        }
    }
};

Find Minimum in Rotated Sorted Array II

有重复元素，注意什么时候才可以断定mid在左半部？边界比较tricky

class Solution {
public:
    int findMin(vector<int> &num) {
        return helper(num, 0, num.size()-1);
    }
    int helper(vector<int> &num, int l, int r) {
        if (l > r) return INT_MAX;
        if (num[l] < num[r]) return num[l];  //Basecase
        if (l + 1 == r || l == r) return min(num[l], num[r]);
        int mid = l + (r - l) / 2;
        if (num[l] == num[mid] && num[mid] == num[r]) 
            return min(helper(num, l, mid - 1), helper(num, mid+1, r));
        if (num[l] < num[mid] || num[mid] > num[r])  //mid 在左半部
            return helper(num, mid+1, r);
        else
            return helper(num, l, mid);
    }
};

3. Search for a Range

思路：分别找左边界和右边界，

class Solution {
public:
    vector<int> searchRange(int A[], int n, int target) {
        //find left boundary and right boundary separately
        vector<int> rs({-1, -1});
        int l1 = 0, r1 = n-1;
        while (l1 <= r1) {
            int mid = l1 + (r1 - l1) / 2;
            if (target <= A[mid]) r1 = mid - 1;
            else l1 = mid + 1;
        }
        if (l1 < n && A [l1] == target) rs[0] = l1;
        
        int l2 = 0, r2 = n-1;
        while (l2 <= r2) {
            int mid = l2 + (r2 - l2) / 2;
            if (target >= A[mid]) l2 = mid + 1;
            else r2 = mid - 1;
        }
        if (r2 >= 0 && A[r2] == target) rs[1] = r2;
        return rs;
    }
};

3.   Search in Row Wise and Column Wise Sorted Matrix

1) Start with top right element
2) Loop: compare this element e with x
…i) if they are equal then return its position
…ii) e < x then move it to down (if out of bound of matrix then break return false)
…iii) e > x then move it to left (if out of bound of matrix then break return false)</span>

3) repeat the i), ii) and iii) till you find element or returned false

这是一个不断去掉不可能的部分的过程：

 

方框框起来的部分就是每一步去掉的不可能的部分。

geeksforgeeks代码：

int search(int mat[4][4], int n, int x)
{
   int i = 0, j = n-1;  //set indexes for top right element
   while ( i < n && j >= 0 )
   {
      if ( mat[i][j] == x )
      {
         printf("\n Found at %d, %d", i, j);
         return 1;
      }
      if ( mat[i][j] > x )
        j--;
      else //  if mat[i][j] < x
        i++;
   }
 
   printf("\n Element not found");
   return 0;  // if ( i==n || j== -1 )
}