Leetcode日记（9）

Divide Two Integers

问题描述

    Divide two integers without using multiplication, division and mod operator.
    If it is overflow, return MAX_INT.

分析

       题目要求不能使用乘除取余，如果单单依靠减法操作，也是一种解决思路，但并不是高效的，所以使用移位运算符。

解答

class Solution {
public:
    int divide(int dividend, int divisor) {
        if (!divisor || (dividend == INT_MIN && divisor == -1))
            return INT_MAX;
        int flag = 1;
        long long dvd = dividend;
        long long dvs = divisor;
        if (dividend < 0)
        {
            flag = -flag;
            dvd = -dvd;
        }
        if (divisor < 0)
        {
            flag = -flag;
            dvs = -dvs;
        }
        int result = 0;
        while (dvd >= dvs) 
        { 
            long long temp = dvs;
            int multiple = 1;
            while (dvd >= (temp << 1)) 
            {
                temp <<= 1;
                multiple <<= 1;
            }
            dvd -= temp;
            result += multiple;
        }
        return flag == 1 ? result : -result;
    }
};

Search in Rotated Sorted Array

问题描述

    Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
    (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
    You are given a target value to search. If found in the array return its index, otherwise return -1.
    You may assume no duplicate exists in the array.

分析

       考察的是二分查找，由于数组的顺序有变化，需要在改变边界值时做出调整。

解答

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int front = 0;
        int back = nums.size();
        while (front < back)
        {
            int mid = front + (back - front) / 2;
            if (nums[mid] == target)
                return mid;
            if(nums[front] <= nums[mid])
                if (nums[front] <= target && nums[mid] > target)
                    back = mid;
                else
                    front = mid + 1;
            else
                if (nums[back - 1] >= target && nums[mid] < target)
                    front = mid + 1;
                else
                    back = mid;
        }
        return -1;
    }
};

Search for a Range

问题描述

        Given an array of integers sorted in ascending order, 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].

分析

       同样使用二分查找，由于要确定的是查找值的范围，使用两次二分查找确定它的区域。

解答

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result(2, -1);
        if (nums.empty())
            return result;
        int front = 0;
        int back = nums.size() - 1;
        while (front < back)
        {
            int mid = (front + back) / 2;
            if (nums[mid] < target) 
                front = mid + 1;
            else 
                back = mid;
        }
        if (nums[front] != target) 
            return result;
        else 
            result[0] = front;
        back = nums.size() - 1;
        while (front < back)
        {
            int mid = (front + back) /2 + 1;
            if (nums[mid] > target) 
                back = mid - 1;
            else 
                front = mid;
        }
        result[1] = front;
        return result;
    }
};