For the search topic , Generally speaking, we can start with the two methods of violent solution and binary search .

One 、 In an ascending array , Find a target value

Given a Elements in ascending order 、 An integer array without duplicate numbers nums And a target value target , Write a function search nums Medium target, If the target value has a return subscript （ Subscript from 0 Start ）, Otherwise return to -1
Solution 1 ： Violence solution

    int search(vector<int>& nums, int target) {
        // write code here
        //  Violence solution 
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i] == target)
                return i;
        }
        return -1;
	}

Solution 2 ：

    int search(vector<int>& nums, int target) {
        // write code here
        int l= 0;
        int r = nums.size()-1;
        if(!nums.size())
        {
            return -1; 
        }
        while(l<=r)
        {
            int mid = l + (r - l)/2;
            if(nums[mid] < target)
            {
                l = mid +1;
            }
            else if(nums[mid] > target)
            {
                r = mid -1;
            }
            else
            {
                return mid;
            }
        }
        return -1;
    }

Two 、 Search in a two-dimensional array

In a two-dimensional array array in （ Each one-dimensional array has the same length ）, Each row is sorted in ascending order from left to right , Each column is sorted in ascending order from top to bottom . Please complete a function , Enter such a two-dimensional array and an integer , Determine whether the array contains the integer .
Solution 1 ： Violence solution

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        //  Violence solution 
        for(int i = 0;i< array.size();i++)
            for(int j = 0;j< array[i].size();j++)
            {
                if(array[i][j] == target)
                {
                    return true;
                }
            }
        return false;
    }
};

Solution 2 ： Two points search

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        //  Two points search 
        for(int i=0;i<array.size();i++){
            int low=0;
            int high=array[i].size()-1;
            while(low<=high){
                int mid=(low+high)/2;
                if(target>array[i][mid])
                    low=mid+1;
                else if(target<array[i][mid])
                    high=mid-1;
                else
                    return true;
            }
        }
        return false;
    }
};

Solution 3 ：

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int rows = array.size();
        int cols = array.size();
        int i = rows-1;    //  Element coordinates in the lower left corner 
        int j = 0;
        if(!array.size())
            return false;
        if(!array[0].size())
            return false;
        while(i>=0 and array[i][j])
        {
            if(target < array[i][j])
            {
                i--;        //  Find smaller elements , Start looking for the first number up 
            }
            else if(target>array[i][j])
                j++;    //  The element you are looking for is larger , Look back 
            else 
                return true;    //  find 
        }
        return false;
    }
};