LeetCode - Search for a Range

Search for a Range

2014.2.13 20:27

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,
Given [5, 7, 7, 8, 8, 10] and target value 8,
return [3, 4].

Solution1:

　　Apparently this problem is a test for binary search. You could either use the function upper_bound() and lower_bound() provided by STL <algorithm>, or write one for yourself.

　　Total time complexity is O(log(n)). Space complexity is O(1).

Accepted code:

 1 // 1AC, the code can be shorter, but..1AC is just fine.
 2 class Solution {
 3 public:
 4     vector<int> searchRange(int A[], int n, int target) {
 5         vector<int> res;
 6         int ll, rr, mm;
 7         int i1, i2;
 8         
 9         if (A == nullptr || n <= 0) {
10             res.push_back(-1);
11             res.push_back(-1);
12             return res;
13         }
14         
15         if (n == 1) {
16             if (A[0] == target) {
17                 res.push_back(0);
18                 res.push_back(0);
19             } else {
20                 res.push_back(-1);
21                 res.push_back(-1);
22             }
23             return res;
24         }
25         
26         if (target < A[0] || target > A[n - 1]) {
27             res.push_back(-1);
28             res.push_back(-1);
29             return res;
30         }
31         
32         if (target == A[0]) {
33             i1 = 0;
34         } else {
35             ll = 0;
36             rr = n - 1;
37             while (rr - ll > 1) {
38                 mm = (ll + rr) / 2;
39                 if (A[mm] < target) {
40                     ll = mm;
41                 } else {
42                     rr = mm;
43                 }
44             }
45             if (A[rr] != target) {
46                 res.push_back(-1);
47                 res.push_back(-1);
48                 return res;
49             } else {
50                 i1 = rr;
51             }
52         }
53         
54         if (target == A[n - 1]) {
55             i2 = n - 1;
56         } else {
57             ll = 0;
58             rr = n - 1;
59             while (rr - ll > 1) {
60                 mm = (ll + rr) / 2;
61                 if (A[mm] > target) {
62                     rr = mm;
63                 } else {
64                     ll = mm;
65                 }
66             }
67             if (A[ll] != target) {
68                 res.push_back(-1);
69                 res.push_back(-1);
70                 return res;
71             } else {
72                 i2 = ll;
73             }
74         }
75         res.push_back(i1);
76         res.push_back(i2);
77         return res;
78     }
79 };

Solution2:

　　The STL version.

Accepted code:

 1 // 1AC, very smooth.
 2 #include <algorithm>
 3 using namespace std;
 4 
 5 class Solution {
 6 public:
 7     vector<int> searchRange(int A[], int n, int target) {
 8         vector<int> res;
 9         
10         res.push_back(-1);
11         res.push_back(-1);
12         if (A == nullptr) {
13             return res;
14         }
15         
16         int *px, *py;
17         int ix, iy;
18         
19         px = lower_bound(A, A + n, target);
20         ix = px - A;
21         if (ix >= n || A[ix] != target) {
22             // not found
23             return res;
24         }
25         
26         py = upper_bound(A, A + n, target);
27         --py;
28         iy = py - A;
29         res[0] = ix;
30         res[1] = iy;
31         
32         return res;
33     }
34 };

 

 posted on 2014-02-13 20:42  zhuli19901106  阅读(165)  评论(0)  编辑  收藏  举报