旋转数组类的题目

题目描述：

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

题目来源：剑指offer

解决代码：

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size() == 0)
            return 0;
        int i = 0,j = rotateArray.size()-1,mid;
        while(i <= j)
        {
            mid = (i + j)/2;
            if(rotateArray[mid] < rotateArray[mid-1])
                break;
            if(rotateArray[j] < rotateArray[mid])
            {
                i = mid+1;
            }
            else
            {
                j = mid-1;
            }

        }
        return rotateArray[mid];
    }
};

题目描述：

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

题目来源：LeetCode（189. 旋转数组）

解决代码：

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        k = k%nums.size();
        if(k == 0)
            return;
        
        for(int i = 0;i<k;i++)
        {
            int j = nums.size()-1;
            int tmp = nums[j];
            for(;j>0;j--)
            {
                nums[j] = nums[j-1];
            }
            nums[0] = tmp;
        }
    }
};

题目描述：

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

题目来源：LeetCode（33. 搜索旋转排序数组）
解决代码：

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

题目描述：

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

题目来源：LeetCode（81. 搜索旋转排序数组 II）

解决代码：

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

题目描述：

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

注意数组中可能存在重复的元素。

题目来源：LeetCode（154. 寻找旋转排序数组中的最小值 II）
解决代码：

class Solution {
public:
    int findMin(vector<int>& nums) {
        int i = 0,j = nums.size()-1,mid;
        while(i < j)
        {
            mid = i+(j-i)/2;
            if(nums[i] == nums[j] && nums[i] == nums[mid])
                return func(nums,i,j);
            if(nums[mid] > nums[j])
                i = mid+1;
            else
                j = mid;
        }
        return nums[i];
    }
    int func(vector<int> &nums,int l ,int r)
    {
        int minNum = INT_MAX;
        for(int i = l;i<=r;i++)
        {
            if(nums[i] < minNum)
                minNum = nums[i];
        }
        return minNum;
    }
};