leetcode 34 search for a range

最新推荐文章于 2024-07-25 11:23:22 发布

ruihuank

最新推荐文章于 2024-07-25 11:23:22 发布

阅读量174

点赞数

分类专栏： leetcode 笔记文章标签： leetcode

本文链接：https://blog.csdn.net/ruihuank/article/details/78124729

版权

leetcode 笔记专栏收录该内容

127 篇文章 0 订阅

订阅专栏

递归

class Solution {
public:
    typedef vector<int>::size_type sz;

    vector<int> searchRange(vector<int>& nums, int target) {
        sz size = nums.size();
        if (size == 0) return vector<int>(2, -1);
        vector<int> ret;

        // the ragne we are finding is [left, right]
        int left = 0;
        int right = size - 1;
        int mark = -1;

        while(left <= right) {

            int piv = (left + right) / 2; //向左偏
            if (nums[piv] == target) {
                mark = piv; // left mark the index of the number which is equal to target
                break;
            }
            else if (nums[piv] < target){
                    left = piv + 1;
            }
            else {
                    right = piv - 1;
            }

        }

        if (mark == -1) // no number in the nums is equal to target 
            return vector<int>(2, -1);
        else {
            cout << mark << endl;
            ret.push_back(leftFind(nums, 0, mark, target));
            ret.push_back(rightFind(nums, mark, size - 1, target));
        }
        return ret;

    }
private:

    // find the left boundary 
    int leftFind(vector<int>& v, size_t b, size_t e, int target) {
        if (b == e) 
            return e;

        size_t piv = (b + e) / 2;
        if (v[piv] == target) 
            return leftFind(v, b, piv, target);
        else
            return leftFind(v, piv + 1, e, target);
    }

    // find the right boundary
    int rightFind(vector<int>& v, size_t b, size_t e, int target) {
        if (b == e) 
            return b;

        size_t piv = (b + e + 1) / 2;
        if (v[piv] == target)
            return rightFind(v, piv, e, target);
        else
            return rightFind(v, b, piv - 1, target);
    }
};

hehe

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> ret(2, -1);

        typedef vector<int>::iterator It;

        pair<It, It> p = equal_range(nums.begin(), nums.end(), target);
        if (p.first != p.second) {
            ret[0] = p.first - nums.begin();
            ret[1] = p.second - nums.begin() - 1;
        }
        return ret;
    }
};

参考后

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int size = nums.size();
        vector<int> ret(2, -1);
        if (size == 0) return ret;

        int left = -1;
        int right = -1;
        // find left boundary
        int l = 0;
        int r = size - 1;

        while (l < r) {
            int mid = (l + r) / 2; // 向左偏

            if (nums[mid] < target) 
                l = mid + 1;
            else 
                r = mid;
        }

        if (nums[l] == target) 
            left = l;
        else return ret; // 没有数字和 target 相同

        // find right boundary
        l = left;
        r = size - 1;

        while (l < r) {
            int mid = (l + r + 1) / 2;  // 向右偏 不然 r = mid -1 会小于0

            if (nums[mid] > target)
                r = mid - 1;
            else 
                l = mid;  // 不能是 mid -1 因为nums[l] 可能是target
        }
        right = r;

        ret[0] = left;
        ret[1] = right;
        return ret; 
    }
};